tests/phpunit/includes/TitleTest.php

   1 <?php
   2
   3 use MediaWiki\Linker\LinkTarget;
   4 use MediaWiki\MediaWikiServices;
   5 use Wikimedia\TestingAccessWrapper;
   6
   7 /**
   8  * @group Database
   9  * @group Title
  10  */
  11 class TitleTest extends MediaWikiTestCase {
  12         protected function setUp() {
  13                 parent::setUp();
  14
  15                 $this->setMwGlobals( [
  16                         'wgAllowUserJs' => false,
  17                         'wgDefaultLanguageVariant' => false,
  18                         'wgMetaNamespace' => 'Project',
  19                 ] );
  20                 $this->setUserLang( 'en' );
  21                 $this->setContentLang( 'en' );
  22         }
  23
  24         protected function tearDown() {
  25                 // For testNewMainPage
  26                 MessageCache::destroyInstance();
  27                 parent::tearDown();
  28         }
  29
  30         /**
  31          * @covers Title::legalChars
  32          */
  33         public function testLegalChars() {
  34                 $titlechars = Title::legalChars();
  35
  36                 foreach ( range( 1, 255 ) as $num ) {
  37                         $chr = chr( $num );
  38                         if ( strpos( "#[]{}<>|", $chr ) !== false || preg_match( "/[\\x00-\\x1f\\x7f]/", $chr ) ) {
  39                                 $this->assertFalse(
  40                                         (bool)preg_match( "/[$titlechars]/", $chr ),
  41                                         "chr($num) = $chr is not a valid titlechar"
  42                                 );
  43                         } else {
  44                                 $this->assertTrue(
  45                                         (bool)preg_match( "/[$titlechars]/", $chr ),
  46                                         "chr($num) = $chr is a valid titlechar"
  47                                 );
  48                         }
  49                 }
  50         }
  51
  52         public static function provideValidSecureAndSplit() {
  53                 return [
  54                         [ 'Sandbox' ],
  55                         [ 'A "B"' ],
  56                         [ 'A \'B\'' ],
  57                         [ '.com' ],
  58                         [ '~' ],
  59                         [ '#' ],
  60                         [ '"' ],
  61                         [ '\'' ],
  62                         [ 'Talk:Sandbox' ],
  63                         [ 'Talk:Foo:Sandbox' ],
  64                         [ 'File:Example.svg' ],
  65                         [ 'File_talk:Example.svg' ],
  66                         [ 'Foo/.../Sandbox' ],
  67                         [ 'Sandbox/...' ],
  68                         [ 'A~~' ],
  69                         [ ':A' ],
  70                         // Length is 256 total, but only title part matters
  71                         [ 'Category:' . str_repeat( 'x', 248 ) ],
  72                         [ str_repeat( 'x', 252 ) ],
  73                         // interwiki prefix
  74                         [ 'localtestiw: #anchor' ],
  75                         [ 'localtestiw:' ],
  76                         [ 'localtestiw:foo' ],
  77                         [ 'localtestiw: foo # anchor' ],
  78                         [ 'localtestiw: Talk: Sandbox # anchor' ],
  79                         [ 'remotetestiw:' ],
  80                         [ 'remotetestiw: Talk: # anchor' ],
  81                         [ 'remotetestiw: #bar' ],
  82                         [ 'remotetestiw: Talk:' ],
  83                         [ 'remotetestiw: Talk: Foo' ],
  84                         [ 'localtestiw:remotetestiw:' ],
  85                         [ 'localtestiw:remotetestiw:foo' ]
  86                 ];
  87         }
  88
  89         public static function provideInvalidSecureAndSplit() {
  90                 return [
  91                         [ '', 'title-invalid-empty' ],
  92                         [ ':', 'title-invalid-empty' ],
  93                         [ '__  __', 'title-invalid-empty' ],
  94                         [ '  __  ', 'title-invalid-empty' ],
  95                         // Bad characters forbidden regardless of wgLegalTitleChars
  96                         [ 'A [ B', 'title-invalid-characters' ],
  97                         [ 'A ] B', 'title-invalid-characters' ],
  98                         [ 'A { B', 'title-invalid-characters' ],
  99                         [ 'A } B', 'title-invalid-characters' ],
 100                         [ 'A < B', 'title-invalid-characters' ],
 101                         [ 'A > B', 'title-invalid-characters' ],
 102                         [ 'A | B', 'title-invalid-characters' ],
 103                         [ "A \t B", 'title-invalid-characters' ],
 104                         [ "A \n B", 'title-invalid-characters' ],
 105                         // URL encoding
 106                         [ 'A%20B', 'title-invalid-characters' ],
 107                         [ 'A%23B', 'title-invalid-characters' ],
 108                         [ 'A%2523B', 'title-invalid-characters' ],
 109                         // XML/HTML character entity references
 110                         // Note: Commented out because they are not marked invalid by the PHP test as
 111                         // Title::newFromText runs Sanitizer::decodeCharReferencesAndNormalize first.
 112                         // 'A &eacute; B',
 113                         // 'A &#233; B',
 114                         // 'A &#x00E9; B',
 115                         // Subject of NS_TALK does not roundtrip to NS_MAIN
 116                         [ 'Talk:File:Example.svg', 'title-invalid-talk-namespace' ],
 117                         // Directory navigation
 118                         [ '.', 'title-invalid-relative' ],
 119                         [ '..', 'title-invalid-relative' ],
 120                         [ './Sandbox', 'title-invalid-relative' ],
 121                         [ '../Sandbox', 'title-invalid-relative' ],
 122                         [ 'Foo/./Sandbox', 'title-invalid-relative' ],
 123                         [ 'Foo/../Sandbox', 'title-invalid-relative' ],
 124                         [ 'Sandbox/.', 'title-invalid-relative' ],
 125                         [ 'Sandbox/..', 'title-invalid-relative' ],
 126                         // Tilde
 127                         [ 'A ~~~ Name', 'title-invalid-magic-tilde' ],
 128                         [ 'A ~~~~ Signature', 'title-invalid-magic-tilde' ],
 129                         [ 'A ~~~~~ Timestamp', 'title-invalid-magic-tilde' ],
 130                         // Length
 131                         [ str_repeat( 'x', 256 ), 'title-invalid-too-long' ],
 132                         // Namespace prefix without actual title
 133                         [ 'Talk:', 'title-invalid-empty' ],
 134                         [ 'Talk:#', 'title-invalid-empty' ],
 135                         [ 'Category: ', 'title-invalid-empty' ],
 136                         [ 'Category: #bar', 'title-invalid-empty' ],
 137                         // interwiki prefix
 138                         [ 'localtestiw: Talk: # anchor', 'title-invalid-empty' ],
 139                         [ 'localtestiw: Talk:', 'title-invalid-empty' ]
 140                 ];
 141         }
 142
 143         private function secureAndSplitGlobals() {
 144                 $this->setMwGlobals( [
 145                         'wgLocalInterwikis' => [ 'localtestiw' ],
 146                         'wgHooks' => [
 147                                 'InterwikiLoadPrefix' => [
 148                                         function ( $prefix, &$data ) {
 149                                                 if ( $prefix === 'localtestiw' ) {
 150                                                         $data = [ 'iw_url' => 'localtestiw' ];
 151                                                 } elseif ( $prefix === 'remotetestiw' ) {
 152                                                         $data = [ 'iw_url' => 'remotetestiw' ];
 153                                                 }
 154                                                 return false;
 155                                         }
 156                                 ]
 157                         ]
 158                 ] );
 159
 160                 $this->overrideMwServices();
 161         }
 162
 163         /**
 164          * See also mediawiki.Title.test.js
 165          * @covers Title::secureAndSplit
 166          * @dataProvider provideValidSecureAndSplit
 167          * @note This mainly tests MediaWikiTitleCodec::parseTitle().
 168          */
 169         public function testSecureAndSplitValid( $text ) {
 170                 $this->secureAndSplitGlobals();
 171                 $this->assertInstanceOf( Title::class, Title::newFromText( $text ), "Valid: $text" );
 172         }
 173
 174         /**
 175          * See also mediawiki.Title.test.js
 176          * @covers Title::secureAndSplit
 177          * @dataProvider provideInvalidSecureAndSplit
 178          * @note This mainly tests MediaWikiTitleCodec::parseTitle().
 179          */
 180         public function testSecureAndSplitInvalid( $text, $expectedErrorMessage ) {
 181                 $this->secureAndSplitGlobals();
 182                 try {
 183                         Title::newFromTextThrow( $text ); // should throw
 184                         $this->assertTrue( false, "Invalid: $text" );
 185                 } catch ( MalformedTitleException $ex ) {
 186                         $this->assertEquals( $expectedErrorMessage, $ex->getErrorMessage(), "Invalid: $text" );
 187                 }
 188         }
 189
 190         public static function provideConvertByteClassToUnicodeClass() {
 191                 return [
 192                         [
 193                                 ' %!"$&\'()*,\\-.\\/0-9:;=?@A-Z\\\\^_`a-z~\\x80-\\xFF+',
 194                                 ' %!"$&\'()*,\\-./0-9:;=?@A-Z\\\\\\^_`a-z~+\\u0080-\\uFFFF',
 195                         ],
 196                         [
 197                                 'QWERTYf-\\xFF+',
 198                                 'QWERTYf-\\x7F+\\u0080-\\uFFFF',
 199                         ],
 200                         [
 201                                 'QWERTY\\x66-\\xFD+',
 202                                 'QWERTYf-\\x7F+\\u0080-\\uFFFF',
 203                         ],
 204                         [
 205                                 'QWERTYf-y+',
 206                                 'QWERTYf-y+',
 207                         ],
 208                         [
 209                                 'QWERTYf-\\x80+',
 210                                 'QWERTYf-\\x7F+\\u0080-\\uFFFF',
 211                         ],
 212                         [
 213                                 'QWERTY\\x66-\\x80+\\x23',
 214                                 'QWERTYf-\\x7F+#\\u0080-\\uFFFF',
 215                         ],
 216                         [
 217                                 'QWERTY\\x66-\\x80+\\xD3',
 218                                 'QWERTYf-\\x7F+\\u0080-\\uFFFF',
 219                         ],
 220                         [
 221                                 '\\\\\\x99',
 222                                 '\\\\\\u0080-\\uFFFF',
 223                         ],
 224                         [
 225                                 '-\\x99',
 226                                 '\\-\\u0080-\\uFFFF',
 227                         ],
 228                         [
 229                                 'QWERTY\\-\\x99',
 230                                 'QWERTY\\-\\u0080-\\uFFFF',
 231                         ],
 232                         [
 233                                 '\\\\x99',
 234                                 '\\\\x99',
 235                         ],
 236                         [
 237                                 'A-\\x9F',
 238                                 'A-\\x7F\\u0080-\\uFFFF',
 239                         ],
 240                         [
 241                                 '\\x66-\\x77QWERTY\\x88-\\x91FXZ',
 242                                 'f-wQWERTYFXZ\\u0080-\\uFFFF',
 243                         ],
 244                         [
 245                                 '\\x66-\\x99QWERTY\\xAA-\\xEEFXZ',
 246                                 'f-\\x7FQWERTYFXZ\\u0080-\\uFFFF',
 247                         ],
 248                 ];
 249         }
 250
 251         /**
 252          * @dataProvider provideConvertByteClassToUnicodeClass
 253          * @covers Title::convertByteClassToUnicodeClass
 254          */
 255         public function testConvertByteClassToUnicodeClass( $byteClass, $unicodeClass ) {
 256                 $this->assertEquals( $unicodeClass, Title::convertByteClassToUnicodeClass( $byteClass ) );
 257         }
 258
 259         /**
 260          * @dataProvider provideSpecialNamesWithAndWithoutParameter
 261          * @covers Title::fixSpecialName
 262          */
 263         public function testFixSpecialNameRetainsParameter( $text, $expectedParam ) {
 264                 $title = Title::newFromText( $text );
 265                 $fixed = $title->fixSpecialName();
 266                 $stuff = explode( '/', $fixed->getDBkey(), 2 );
 267                 if ( count( $stuff ) == 2 ) {
 268                         $par = $stuff[1];
 269                 } else {
 270                         $par = null;
 271                 }
 272                 $this->assertEquals(
 273                         $expectedParam,
 274                         $par,
 275                         "T33100 regression check: Title->fixSpecialName() should preserve parameter"
 276                 );
 277         }
 278
 279         public static function provideSpecialNamesWithAndWithoutParameter() {
 280                 return [
 281                         [ 'Special:Version', null ],
 282                         [ 'Special:Version/', '' ],
 283                         [ 'Special:Version/param', 'param' ],
 284                 ];
 285         }
 286
 287         /**
 288          * Auth-less test of Title::isValidMoveOperation
 289          *
 290          * @param string $source
 291          * @param string $target
 292          * @param array|string|bool $expected Required error
 293          * @dataProvider provideTestIsValidMoveOperation
 294          * @covers Title::isValidMoveOperation
 295          */
 296         public function testIsValidMoveOperation( $source, $target, $expected ) {
 297                 $this->setMwGlobals( 'wgContentHandlerUseDB', false );
 298                 $title = Title::newFromText( $source );
 299                 $nt = Title::newFromText( $target );
 300                 $errors = $title->isValidMoveOperation( $nt, false );
 301                 if ( $expected === true ) {
 302                         $this->assertTrue( $errors );
 303                 } else {
 304                         $errors = $this->flattenErrorsArray( $errors );
 305                         foreach ( (array)$expected as $error ) {
 306                                 $this->assertContains( $error, $errors );
 307                         }
 308                 }
 309         }
 310
 311         public static function provideTestIsValidMoveOperation() {
 312                 return [
 313                         // for Title::isValidMoveOperation
 314                         [ 'Some page', '', 'badtitletext' ],
 315                         [ 'Test', 'Test', 'selfmove' ],
 316                         [ 'Special:FooBar', 'Test', 'immobile-source-namespace' ],
 317                         [ 'Test', 'Special:FooBar', 'immobile-target-namespace' ],
 318                         [ 'MediaWiki:Common.js', 'Help:Some wikitext page', 'bad-target-model' ],
 319                         [ 'Page', 'File:Test.jpg', 'nonfile-cannot-move-to-file' ],
 320                         [ 'File:Test.jpg', 'Page', 'imagenocrossnamespace' ],
 321                 ];
 322         }
 323
 324         /**
 325          * Auth-less test of Title::userCan
 326          *
 327          * @param array $whitelistRegexp
 328          * @param string $source
 329          * @param string $action
 330          * @param array|string|bool $expected Required error
 331          *
 332          * @covers \Mediawiki\Permissions\PermissionManager::checkReadPermissions
 333          * @dataProvider dataWgWhitelistReadRegexp
 334          */
 335         public function testWgWhitelistReadRegexp( $whitelistRegexp, $source, $action, $expected ) {
 336                 // $wgWhitelistReadRegexp must be an array. Since the provided test cases
 337                 // usually have only one regex, it is more concise to write the lonely regex
 338                 // as a string. Thus we cast to an array() to honor $wgWhitelistReadRegexp
 339                 // type requisite.
 340                 if ( is_string( $whitelistRegexp ) ) {
 341                         $whitelistRegexp = [ $whitelistRegexp ];
 342                 }
 343
 344                 $this->setMwGlobals( [
 345                         // So User::isEveryoneAllowed( 'read' ) === false
 346                         'wgGroupPermissions' => [ '*' => [ 'read' => false ] ],
 347                         'wgWhitelistRead' => [ 'some random non sense title' ],
 348                         'wgWhitelistReadRegexp' => $whitelistRegexp,
 349                 ] );
 350
 351                 $title = Title::newFromDBkey( $source );
 352
 353                 // New anonymous user with no rights
 354                 $user = new User;
 355                 $user->mRights = [];
 356                 $errors = $title->userCan( $action, $user );
 357
 358                 if ( is_bool( $expected ) ) {
 359                         # Forge the assertion message depending on the assertion expectation
 360                         $allowableness = $expected
 361                                 ? " should be allowed"
 362                                 : " should NOT be allowed";
 363                         $this->assertEquals(
 364                                 $expected,
 365                                 $errors,
 366                                 "User action '$action' on [[$source]] $allowableness."
 367                         );
 368                 } else {
 369                         $errors = $this->flattenErrorsArray( $errors );
 370                         foreach ( (array)$expected as $error ) {
 371                                 $this->assertContains( $error, $errors );
 372                         }
 373                 }
 374         }
 375
 376         /**
 377          * Provides test parameter values for testWgWhitelistReadRegexp()
 378          */
 379         public function dataWgWhitelistReadRegexp() {
 380                 $ALLOWED = true;
 381                 $DISALLOWED = false;
 382
 383                 return [
 384                         // Everything, if this doesn't work, we're really in trouble
 385                         [ '/.*/', 'Main_Page', 'read', $ALLOWED ],
 386                         [ '/.*/', 'Main_Page', 'edit', $DISALLOWED ],
 387
 388                         // We validate against the title name, not the db key
 389                         [ '/^Main_Page$/', 'Main_Page', 'read', $DISALLOWED ],
 390                         // Main page
 391                         [ '/^Main/', 'Main_Page', 'read', $ALLOWED ],
 392                         [ '/^Main.*/', 'Main_Page', 'read', $ALLOWED ],
 393                         // With spaces
 394                         [ '/Mic\sCheck/', 'Mic Check', 'read', $ALLOWED ],
 395                         // Unicode multibyte
 396                         // ...without unicode modifier
 397                         [ '/Unicode Test . Yes/', 'Unicode Test Ñ Yes', 'read', $DISALLOWED ],
 398                         // ...with unicode modifier
 399                         [ '/Unicode Test . Yes/u', 'Unicode Test Ñ Yes', 'read', $ALLOWED ],
 400                         // Case insensitive
 401                         [ '/MiC ChEcK/', 'mic check', 'read', $DISALLOWED ],
 402                         [ '/MiC ChEcK/i', 'mic check', 'read', $ALLOWED ],
 403
 404                         // From DefaultSettings.php:
 405                         [ "@^UsEr.*@i", 'User is banned', 'read', $ALLOWED ],
 406                         [ "@^UsEr.*@i", 'User:John Doe', 'read', $ALLOWED ],
 407
 408                         // With namespaces:
 409                         [ '/^Special:NewPages$/', 'Special:NewPages', 'read', $ALLOWED ],
 410                         [ null, 'Special:Newpages', 'read', $DISALLOWED ],
 411
 412                 ];
 413         }
 414
 415         public function flattenErrorsArray( $errors ) {
 416                 $result = [];
 417                 foreach ( $errors as $error ) {
 418                         $result[] = $error[0];
 419                 }
 420
 421                 return $result;
 422         }
 423
 424         /**
 425          * @dataProvider provideGetPageViewLanguage
 426          * @covers Title::getPageViewLanguage
 427          */
 428         public function testGetPageViewLanguage( $expected, $titleText, $contLang,
 429                 $lang, $variant, $msg = ''
 430         ) {
 431                 // Setup environnement for this test
 432                 $this->setMwGlobals( [
 433                         'wgDefaultLanguageVariant' => $variant,
 434                         'wgAllowUserJs' => true,
 435                 ] );
 436                 $this->setUserLang( $lang );
 437                 $this->setContentLang( $contLang );
 438
 439                 $title = Title::newFromText( $titleText );
 440                 $this->assertInstanceOf( Title::class, $title,
 441                         "Test must be passed a valid title text, you gave '$titleText'"
 442                 );
 443                 $this->assertEquals( $expected,
 444                         $title->getPageViewLanguage()->getCode(),
 445                         $msg
 446                 );
 447         }
 448
 449         public static function provideGetPageViewLanguage() {
 450                 # Format:
 451                 # - expected
 452                 # - Title name
 453                 # - content language (expected in most cases)
 454                 # - wgLang (on some specific pages)
 455                 # - wgDefaultLanguageVariant
 456                 # - Optional message
 457                 return [
 458                         [ 'fr', 'Help:I_need_somebody', 'fr', 'fr', false ],
 459                         [ 'es', 'Help:I_need_somebody', 'es', 'zh-tw', false ],
 460                         [ 'zh', 'Help:I_need_somebody', 'zh', 'zh-tw', false ],
 461
 462                         [ 'es', 'Help:I_need_somebody', 'es', 'zh-tw', 'zh-cn' ],
 463                         [ 'es', 'MediaWiki:About', 'es', 'zh-tw', 'zh-cn' ],
 464                         [ 'es', 'MediaWiki:About/', 'es', 'zh-tw', 'zh-cn' ],
 465                         [ 'de', 'MediaWiki:About/de', 'es', 'zh-tw', 'zh-cn' ],
 466                         [ 'en', 'MediaWiki:Common.js', 'es', 'zh-tw', 'zh-cn' ],
 467                         [ 'en', 'MediaWiki:Common.css', 'es', 'zh-tw', 'zh-cn' ],
 468                         [ 'en', 'User:JohnDoe/Common.js', 'es', 'zh-tw', 'zh-cn' ],
 469                         [ 'en', 'User:JohnDoe/Monobook.css', 'es', 'zh-tw', 'zh-cn' ],
 470
 471                         [ 'zh-cn', 'Help:I_need_somebody', 'zh', 'zh-tw', 'zh-cn' ],
 472                         [ 'zh', 'MediaWiki:About', 'zh', 'zh-tw', 'zh-cn' ],
 473                         [ 'zh', 'MediaWiki:About/', 'zh', 'zh-tw', 'zh-cn' ],
 474                         [ 'de', 'MediaWiki:About/de', 'zh', 'zh-tw', 'zh-cn' ],
 475                         [ 'zh-cn', 'MediaWiki:About/zh-cn', 'zh', 'zh-tw', 'zh-cn' ],
 476                         [ 'zh-tw', 'MediaWiki:About/zh-tw', 'zh', 'zh-tw', 'zh-cn' ],
 477                         [ 'en', 'MediaWiki:Common.js', 'zh', 'zh-tw', 'zh-cn' ],
 478                         [ 'en', 'MediaWiki:Common.css', 'zh', 'zh-tw', 'zh-cn' ],
 479                         [ 'en', 'User:JohnDoe/Common.js', 'zh', 'zh-tw', 'zh-cn' ],
 480                         [ 'en', 'User:JohnDoe/Monobook.css', 'zh', 'zh-tw', 'zh-cn' ],
 481
 482                         [ 'zh-tw', 'Special:NewPages', 'es', 'zh-tw', 'zh-cn' ],
 483                         [ 'zh-tw', 'Special:NewPages', 'zh', 'zh-tw', 'zh-cn' ],
 484
 485                 ];
 486         }
 487
 488         /**
 489          * @dataProvider provideBaseTitleCases
 490          * @covers Title::getBaseText
 491          */
 492         public function testGetBaseText( $title, $expected, $msg = '' ) {
 493                 $title = Title::newFromText( $title );
 494                 $this->assertEquals( $expected,
 495                         $title->getBaseText(),
 496                         $msg
 497                 );
 498         }
 499
 500         public static function provideBaseTitleCases() {
 501                 return [
 502                         # Title, expected base, optional message
 503                         [ 'User:John_Doe/subOne/subTwo', 'John Doe/subOne' ],
 504                         [ 'User:Foo/Bar/Baz', 'Foo/Bar' ],
 505                 ];
 506         }
 507
 508         /**
 509          * @dataProvider provideRootTitleCases
 510          * @covers Title::getRootText
 511          */
 512         public function testGetRootText( $title, $expected, $msg = '' ) {
 513                 $title = Title::newFromText( $title );
 514                 $this->assertEquals( $expected,
 515                         $title->getRootText(),
 516                         $msg
 517                 );
 518         }
 519
 520         public static function provideRootTitleCases() {
 521                 return [
 522                         # Title, expected base, optional message
 523                         [ 'User:John_Doe/subOne/subTwo', 'John Doe' ],
 524                         [ 'User:Foo/Bar/Baz', 'Foo' ],
 525                 ];
 526         }
 527
 528         /**
 529          * @todo Handle $wgNamespacesWithSubpages cases
 530          * @dataProvider provideSubpageTitleCases
 531          * @covers Title::getSubpageText
 532          */
 533         public function testGetSubpageText( $title, $expected, $msg = '' ) {
 534                 $title = Title::newFromText( $title );
 535                 $this->assertEquals( $expected,
 536                         $title->getSubpageText(),
 537                         $msg
 538                 );
 539         }
 540
 541         public static function provideSubpageTitleCases() {
 542                 return [
 543                         # Title, expected base, optional message
 544                         [ 'User:John_Doe/subOne/subTwo', 'subTwo' ],
 545                         [ 'User:John_Doe/subOne', 'subOne' ],
 546                 ];
 547         }
 548
 549         public static function provideNewFromTitleValue() {
 550                 return [
 551                         [ new TitleValue( NS_MAIN, 'Foo' ) ],
 552                         [ new TitleValue( NS_MAIN, 'Foo', 'bar' ) ],
 553                         [ new TitleValue( NS_USER, 'Hansi_Maier' ) ],
 554                 ];
 555         }
 556
 557         /**
 558          * @covers Title::newFromTitleValue
 559          * @dataProvider provideNewFromTitleValue
 560          */
 561         public function testNewFromTitleValue( TitleValue $value ) {
 562                 $title = Title::newFromTitleValue( $value );
 563
 564                 $dbkey = str_replace( ' ', '_', $value->getText() );
 565                 $this->assertEquals( $dbkey, $title->getDBkey() );
 566                 $this->assertEquals( $value->getNamespace(), $title->getNamespace() );
 567                 $this->assertEquals( $value->getFragment(), $title->getFragment() );
 568         }
 569
 570         /**
 571          * @covers Title::newFromLinkTarget
 572          * @dataProvider provideNewFromTitleValue
 573          */
 574         public function testNewFromLinkTarget( LinkTarget $value ) {
 575                 $title = Title::newFromLinkTarget( $value );
 576
 577                 $dbkey = str_replace( ' ', '_', $value->getText() );
 578                 $this->assertEquals( $dbkey, $title->getDBkey() );
 579                 $this->assertEquals( $value->getNamespace(), $title->getNamespace() );
 580                 $this->assertEquals( $value->getFragment(), $title->getFragment() );
 581         }
 582
 583         /**
 584          * @covers Title::newFromLinkTarget
 585          */
 586         public function testNewFromLinkTarget_clone() {
 587                 $title = Title::newFromText( __METHOD__ );
 588                 $this->assertSame( $title, Title::newFromLinkTarget( $title ) );
 589
 590                 // The Title::NEW_CLONE flag should ensure that a fresh instance is returned.
 591                 $clone = Title::newFromLinkTarget( $title, Title::NEW_CLONE );
 592                 $this->assertNotSame( $title, $clone );
 593                 $this->assertTrue( $clone->equals( $title ) );
 594         }
 595
 596         public function provideCastFromLinkTarget() {
 597                 return array_merge( [ [ null ] ], self::provideNewFromTitleValue() );
 598         }
 599
 600         /**
 601          * @covers Title::castFromLinkTarget
 602          * @dataProvider provideCastFromLinkTarget
 603          */
 604         public function testCastFromLinkTarget( $value ) {
 605                 $title = Title::castFromLinkTarget( $value );
 606
 607                 if ( $value === null ) {
 608                         $this->assertNull( $title );
 609                 } else {
 610                         $dbkey = str_replace( ' ', '_', $value->getText() );
 611                         $this->assertSame( $dbkey, $title->getDBkey() );
 612                         $this->assertSame( $value->getNamespace(), $title->getNamespace() );
 613                         $this->assertSame( $value->getFragment(), $title->getFragment() );
 614                 }
 615         }
 616
 617         public static function provideGetTitleValue() {
 618                 return [
 619                         [ 'Foo' ],
 620                         [ 'Foo#bar' ],
 621                         [ 'User:Hansi_Maier' ],
 622                 ];
 623         }
 624
 625         /**
 626          * @covers Title::getTitleValue
 627          * @dataProvider provideGetTitleValue
 628          */
 629         public function testGetTitleValue( $text ) {
 630                 $title = Title::newFromText( $text );
 631                 $value = $title->getTitleValue();
 632
 633                 $dbkey = str_replace( ' ', '_', $value->getText() );
 634                 $this->assertEquals( $title->getDBkey(), $dbkey );
 635                 $this->assertEquals( $title->getNamespace(), $value->getNamespace() );
 636                 $this->assertEquals( $title->getFragment(), $value->getFragment() );
 637         }
 638
 639         public static function provideGetFragment() {
 640                 return [
 641                         [ 'Foo', '' ],
 642                         [ 'Foo#bar', 'bar' ],
 643                         [ 'Foo#bär', 'bär' ],
 644
 645                         // Inner whitespace is normalized
 646                         [ 'Foo#bar_bar', 'bar bar' ],
 647                         [ 'Foo#bar bar', 'bar bar' ],
 648                         [ 'Foo#bar   bar', 'bar bar' ],
 649
 650                         // Leading whitespace is kept, trailing whitespace is trimmed.
 651                         // XXX: Is this really want we want?
 652                         [ 'Foo#_bar_bar_', ' bar bar' ],
 653                         [ 'Foo# bar bar ', ' bar bar' ],
 654                 ];
 655         }
 656
 657         /**
 658          * @covers Title::getFragment
 659          * @dataProvider provideGetFragment
 660          *
 661          * @param string $full
 662          * @param string $fragment
 663          */
 664         public function testGetFragment( $full, $fragment ) {
 665                 $title = Title::newFromText( $full );
 666                 $this->assertEquals( $fragment, $title->getFragment() );
 667         }
 668
 669         /**
 670          * @covers Title::isAlwaysKnown
 671          * @dataProvider provideIsAlwaysKnown
 672          * @param string $page
 673          * @param bool $isKnown
 674          */
 675         public function testIsAlwaysKnown( $page, $isKnown ) {
 676                 $title = Title::newFromText( $page );
 677                 $this->assertEquals( $isKnown, $title->isAlwaysKnown() );
 678         }
 679
 680         public static function provideIsAlwaysKnown() {
 681                 return [
 682                         [ 'Some nonexistent page', false ],
 683                         [ 'UTPage', false ],
 684                         [ '#test', true ],
 685                         [ 'Special:BlankPage', true ],
 686                         [ 'Special:SomeNonexistentSpecialPage', false ],
 687                         [ 'MediaWiki:Parentheses', true ],
 688                         [ 'MediaWiki:Some nonexistent message', false ],
 689                 ];
 690         }
 691
 692         /**
 693          * @covers Title::isValid
 694          * @dataProvider provideIsValid
 695          * @param Title $title
 696          * @param bool $isValid
 697          */
 698         public function testIsValid( Title $title, $isValid ) {
 699                 $this->assertEquals( $isValid, $title->isValid(), $title->getPrefixedText() );
 700         }
 701
 702         public static function provideIsValid() {
 703                 return [
 704                         [ Title::makeTitle( NS_MAIN, '' ), false ],
 705                         [ Title::makeTitle( NS_MAIN, '<>' ), false ],
 706                         [ Title::makeTitle( NS_MAIN, '|' ), false ],
 707                         [ Title::makeTitle( NS_MAIN, '#' ), false ],
 708                         [ Title::makeTitle( NS_MAIN, 'Test' ), true ],
 709                         [ Title::makeTitle( -33, 'Test' ), false ],
 710                         [ Title::makeTitle( 77663399, 'Test' ), false ],
 711                 ];
 712         }
 713
 714         /**
 715          * @covers Title::isAlwaysKnown
 716          */
 717         public function testIsAlwaysKnownOnInterwiki() {
 718                 $title = Title::makeTitle( NS_MAIN, 'Interwiki link', '', 'externalwiki' );
 719                 $this->assertTrue( $title->isAlwaysKnown() );
 720         }
 721
 722         /**
 723          * @covers Title::exists
 724          */
 725         public function testExists() {
 726                 $title = Title::makeTitle( NS_PROJECT, 'New page' );
 727                 $linkCache = MediaWikiServices::getInstance()->getLinkCache();
 728
 729                 $article = new Article( $title );
 730                 $page = $article->getPage();
 731                 $page->doEditContent( new WikitextContent( 'Some [[link]]' ), 'summary' );
 732
 733                 // Tell Title it doesn't know whether it exists
 734                 $title->mArticleID = -1;
 735
 736                 // Tell the link cache it doesn't exists when it really does
 737                 $linkCache->clearLink( $title );
 738                 $linkCache->addBadLinkObj( $title );
 739
 740                 $this->assertEquals(
 741                         false,
 742                         $title->exists(),
 743                         'exists() should rely on link cache unless GAID_FOR_UPDATE is used'
 744                 );
 745                 $this->assertEquals(
 746                         true,
 747                         $title->exists( Title::GAID_FOR_UPDATE ),
 748                         'exists() should re-query database when GAID_FOR_UPDATE is used'
 749                 );
 750         }
 751
 752         public function provideCanHaveTalkPage() {
 753                 return [
 754                         'User page has talk page' => [
 755                                 Title::makeTitle( NS_USER, 'Jane' ), true
 756                         ],
 757                         'Talke page has talk page' => [
 758                                 Title::makeTitle( NS_TALK, 'Foo' ), true
 759                         ],
 760                         'Special page cannot have talk page' => [
 761                                 Title::makeTitle( NS_SPECIAL, 'Thing' ), false
 762                         ],
 763                         'Virtual namespace cannot have talk page' => [
 764                                 Title::makeTitle( NS_MEDIA, 'Kitten.jpg' ), false
 765                         ],
 766                 ];
 767         }
 768
 769         /**
 770          * @dataProvider provideCanHaveTalkPage
 771          * @covers Title::canHaveTalkPage
 772          *
 773          * @param Title $title
 774          * @param bool $expected
 775          */
 776         public function testCanHaveTalkPage( Title $title, $expected ) {
 777                 $actual = $title->canHaveTalkPage();
 778                 $this->assertSame( $expected, $actual, $title->getPrefixedDBkey() );
 779         }
 780
 781         public static function provideGetTalkPage_good() {
 782                 return [
 783                         [ Title::makeTitle( NS_MAIN, 'Test' ), Title::makeTitle( NS_TALK, 'Test' ) ],
 784                         [ Title::makeTitle( NS_TALK, 'Test' ), Title::makeTitle( NS_TALK, 'Test' ) ],
 785                 ];
 786         }
 787
 788         /**
 789          * @dataProvider provideGetTalkPage_good
 790          * @covers Title::getTalkPage
 791          */
 792         public function testGetTalkPage_good( Title $title, Title $expected ) {
 793                 $talk = $title->getTalkPage();
 794                 $this->assertSame(
 795                         $expected->getPrefixedDBKey(),
 796                         $talk->getPrefixedDBKey(),
 797                         $title->getPrefixedDBKey()
 798                 );
 799         }
 800
 801         /**
 802          * @dataProvider provideGetTalkPage_good
 803          * @covers Title::getTalkPageIfDefined
 804          */
 805         public function testGetTalkPageIfDefined_good( Title $title ) {
 806                 $talk = $title->getTalkPageIfDefined();
 807                 $this->assertInstanceOf(
 808                         Title::class,
 809                         $talk,
 810                         $title->getPrefixedDBKey()
 811                 );
 812         }
 813
 814         public static function provideGetTalkPage_bad() {
 815                 return [
 816                         [ Title::makeTitle( NS_SPECIAL, 'Test' ) ],
 817                         [ Title::makeTitle( NS_MEDIA, 'Test' ) ],
 818                 ];
 819         }
 820
 821         /**
 822          * @dataProvider provideGetTalkPage_bad
 823          * @covers Title::getTalkPageIfDefined
 824          */
 825         public function testGetTalkPageIfDefined_bad( Title $title ) {
 826                 $talk = $title->getTalkPageIfDefined();
 827                 $this->assertNull(
 828                         $talk,
 829                         $title->getPrefixedDBKey()
 830                 );
 831         }
 832
 833         public function provideCreateFragmentTitle() {
 834                 return [
 835                         [ Title::makeTitle( NS_MAIN, 'Test' ), 'foo' ],
 836                         [ Title::makeTitle( NS_TALK, 'Test', 'foo' ), '' ],
 837                         [ Title::makeTitle( NS_CATEGORY, 'Test', 'foo' ), 'bar' ],
 838                         [ Title::makeTitle( NS_MAIN, 'Test1', '', 'interwiki' ), 'baz' ]
 839                 ];
 840         }
 841
 842         /**
 843          * @covers Title::createFragmentTarget
 844          * @dataProvider provideCreateFragmentTitle
 845          */
 846         public function testCreateFragmentTitle( Title $title, $fragment ) {
 847                 $this->mergeMwGlobalArrayValue( 'wgHooks', [
 848                         'InterwikiLoadPrefix' => [
 849                                 function ( $prefix, &$iwdata ) {
 850                                         if ( $prefix === 'interwiki' ) {
 851                                                 $iwdata = [
 852                                                         'iw_url' => 'http://example.com/',
 853                                                         'iw_local' => 0,
 854                                                         'iw_trans' => 0,
 855                                                 ];
 856                                                 return false;
 857                                         }
 858                                 },
 859                         ],
 860                 ] );
 861
 862                 $fragmentTitle = $title->createFragmentTarget( $fragment );
 863
 864                 $this->assertEquals( $title->getNamespace(), $fragmentTitle->getNamespace() );
 865                 $this->assertEquals( $title->getText(), $fragmentTitle->getText() );
 866                 $this->assertEquals( $title->getInterwiki(), $fragmentTitle->getInterwiki() );
 867                 $this->assertEquals( $fragment, $fragmentTitle->getFragment() );
 868         }
 869
 870         public function provideGetPrefixedText() {
 871                 return [
 872                         // ns = 0
 873                         [
 874                                 Title::makeTitle( NS_MAIN, 'Foo bar' ),
 875                                 'Foo bar'
 876                         ],
 877                         // ns = 2
 878                         [
 879                                 Title::makeTitle( NS_USER, 'Foo bar' ),
 880                                 'User:Foo bar'
 881                         ],
 882                         // ns = 3
 883                         [
 884                                 Title::makeTitle( NS_USER_TALK, 'Foo bar' ),
 885                                 'User talk:Foo bar'
 886                         ],
 887                         // fragment not included
 888                         [
 889                                 Title::makeTitle( NS_MAIN, 'Foo bar', 'fragment' ),
 890                                 'Foo bar'
 891                         ],
 892                         // ns = -2
 893                         [
 894                                 Title::makeTitle( NS_MEDIA, 'Foo bar' ),
 895                                 'Media:Foo bar'
 896                         ],
 897                         // non-existent namespace
 898                         [
 899                                 Title::makeTitle( 100777, 'Foo bar' ),
 900                                 'Special:Badtitle/NS100777:Foo bar'
 901                         ],
 902                 ];
 903         }
 904
 905         /**
 906          * @covers Title::getPrefixedText
 907          * @dataProvider provideGetPrefixedText
 908          */
 909         public function testGetPrefixedText( Title $title, $expected ) {
 910                 $this->assertEquals( $expected, $title->getPrefixedText() );
 911         }
 912
 913         public function provideGetPrefixedDBKey() {
 914                 return [
 915                         // ns = 0
 916                         [
 917                                 Title::makeTitle( NS_MAIN, 'Foo_bar' ),
 918                                 'Foo_bar'
 919                         ],
 920                         // ns = 2
 921                         [
 922                                 Title::makeTitle( NS_USER, 'Foo_bar' ),
 923                                 'User:Foo_bar'
 924                         ],
 925                         // ns = 3
 926                         [
 927                                 Title::makeTitle( NS_USER_TALK, 'Foo_bar' ),
 928                                 'User_talk:Foo_bar'
 929                         ],
 930                         // fragment not included
 931                         [
 932                                 Title::makeTitle( NS_MAIN, 'Foo_bar', 'fragment' ),
 933                                 'Foo_bar'
 934                         ],
 935                         // ns = -2
 936                         [
 937                                 Title::makeTitle( NS_MEDIA, 'Foo_bar' ),
 938                                 'Media:Foo_bar'
 939                         ],
 940                         // non-existent namespace
 941                         [
 942                                 Title::makeTitle( 100777, 'Foo_bar' ),
 943                                 'Special:Badtitle/NS100777:Foo_bar'
 944                         ],
 945                 ];
 946         }
 947
 948         /**
 949          * @covers Title::getPrefixedDBKey
 950          * @dataProvider provideGetPrefixedDBKey
 951          */
 952         public function testGetPrefixedDBKey( Title $title, $expected ) {
 953                 $this->assertEquals( $expected, $title->getPrefixedDBkey() );
 954         }
 955
 956         /**
 957          * @covers Title::getFragmentForURL
 958          * @dataProvider provideGetFragmentForURL
 959          *
 960          * @param string $titleStr
 961          * @param string $expected
 962          */
 963         public function testGetFragmentForURL( $titleStr, $expected ) {
 964                 $this->setMwGlobals( [
 965                         'wgFragmentMode' => [ 'html5' ],
 966                         'wgExternalInterwikiFragmentMode' => 'legacy',
 967                 ] );
 968                 $dbw = wfGetDB( DB_MASTER );
 969                 $dbw->insert( 'interwiki',
 970                         [
 971                                 [
 972                                         'iw_prefix' => 'de',
 973                                         'iw_url' => 'http://de.wikipedia.org/wiki/',
 974                                         'iw_api' => 'http://de.wikipedia.org/w/api.php',
 975                                         'iw_wikiid' => 'dewiki',
 976                                         'iw_local' => 1,
 977                                         'iw_trans' => 0,
 978                                 ],
 979                                 [
 980                                         'iw_prefix' => 'zz',
 981                                         'iw_url' => 'http://zzwiki.org/wiki/',
 982                                         'iw_api' => 'http://zzwiki.org/w/api.php',
 983                                         'iw_wikiid' => 'zzwiki',
 984                                         'iw_local' => 0,
 985                                         'iw_trans' => 0,
 986                                 ],
 987                         ],
 988                         __METHOD__,
 989                         [ 'IGNORE' ]
 990                 );
 991
 992                 $title = Title::newFromText( $titleStr );
 993                 self::assertEquals( $expected, $title->getFragmentForURL() );
 994
 995                 $dbw->delete( 'interwiki', '*', __METHOD__ );
 996         }
 997
 998         public function provideGetFragmentForURL() {
 999                 return [
1000                         [ 'Foo', '' ],
1001                         [ 'Foo#ümlåût', '#ümlåût' ],
1002                         [ 'de:Foo#Bå®', '#Bå®' ],
1003                         [ 'zz:Foo#тест', '#.D1.82.D0.B5.D1.81.D1.82' ],
1004                 ];
1005         }
1006
1007         /**
1008          * @covers Title::isRawHtmlMessage
1009          * @dataProvider provideIsRawHtmlMessage
1010          */
1011         public function testIsRawHtmlMessage( $textForm, $expected ) {
1012                 $this->setMwGlobals( 'wgRawHtmlMessages', [
1013                         'foobar',
1014                         'foo_bar',
1015                         'foo-bar',
1016                 ] );
1017
1018                 $title = Title::newFromText( $textForm );
1019                 $this->assertSame( $expected, $title->isRawHtmlMessage() );
1020         }
1021
1022         public function provideIsRawHtmlMessage() {
1023                 return [
1024                         [ 'MediaWiki:Foobar', true ],
1025                         [ 'MediaWiki:Foo bar', true ],
1026                         [ 'MediaWiki:Foo-bar', true ],
1027                         [ 'MediaWiki:foo bar', true ],
1028                         [ 'MediaWiki:foo-bar', true ],
1029                         [ 'MediaWiki:foobar', true ],
1030                         [ 'MediaWiki:some-other-message', false ],
1031                         [ 'Main Page', false ],
1032                 ];
1033         }
1034
1035         public function provideEquals() {
1036                 yield [
1037                         Title::newFromText( 'Main Page' ),
1038                         Title::newFromText( 'Main Page' ),
1039                         true
1040                 ];
1041                 yield [
1042                         Title::newFromText( 'Main Page' ),
1043                         Title::newFromText( 'Not The Main Page' ),
1044                         false
1045                 ];
1046                 yield [
1047                         Title::newFromText( 'Main Page' ),
1048                         Title::newFromText( 'Project:Main Page' ),
1049                         false
1050                 ];
1051                 yield [
1052                         Title::newFromText( 'File:Example.png' ),
1053                         Title::newFromText( 'Image:Example.png' ),
1054                         true
1055                 ];
1056                 yield [
1057                         Title::newFromText( 'Special:Version' ),
1058                         Title::newFromText( 'Special:Version' ),
1059                         true
1060                 ];
1061                 yield [
1062                         Title::newFromText( 'Special:Version' ),
1063                         Title::newFromText( 'Special:Recentchanges' ),
1064                         false
1065                 ];
1066                 yield [
1067                         Title::newFromText( 'Special:Version' ),
1068                         Title::newFromText( 'Main Page' ),
1069                         false
1070                 ];
1071                 yield [
1072                         Title::makeTitle( NS_MAIN, 'Foo', '', '' ),
1073                         Title::makeTitle( NS_MAIN, 'Foo', '', '' ),
1074                         true
1075                 ];
1076                 yield [
1077                         Title::makeTitle( NS_MAIN, 'Foo', '', '' ),
1078                         Title::makeTitle( NS_MAIN, 'Bar', '', '' ),
1079                         false
1080                 ];
1081                 yield [
1082                         Title::makeTitle( NS_MAIN, 'Foo', '', '' ),
1083                         Title::makeTitle( NS_TALK, 'Foo', '', '' ),
1084                         false
1085                 ];
1086                 yield [
1087                         Title::makeTitle( NS_MAIN, 'Foo', 'Bar', '' ),
1088                         Title::makeTitle( NS_MAIN, 'Foo', 'Bar', '' ),
1089                         true
1090                 ];
1091                 yield [
1092                         Title::makeTitle( NS_MAIN, 'Foo', 'Bar', '' ),
1093                         Title::makeTitle( NS_MAIN, 'Foo', 'Baz', '' ),
1094                         true
1095                 ];
1096                 yield [
1097                         Title::makeTitle( NS_MAIN, 'Foo', 'Bar', '' ),
1098                         Title::makeTitle( NS_MAIN, 'Foo', '', '' ),
1099                         true
1100                 ];
1101                 yield [
1102                         Title::makeTitle( NS_MAIN, 'Foo', '', 'baz' ),
1103                         Title::makeTitle( NS_MAIN, 'Foo', '', 'baz' ),
1104                         true
1105                 ];
1106                 yield [
1107                         Title::makeTitle( NS_MAIN, 'Foo', '', '' ),
1108                         Title::makeTitle( NS_MAIN, 'Foo', '', 'baz' ),
1109                         false
1110                 ];
1111         }
1112
1113         /**
1114          * @covers Title::equals
1115          * @dataProvider provideEquals
1116          */
1117         public function testEquals( Title $firstValue, /* LinkTarget */ $secondValue, $expectedSame ) {
1118                 $this->assertSame(
1119                         $expectedSame,
1120                         $firstValue->equals( $secondValue )
1121                 );
1122         }
1123
1124         /**
1125          * @covers Title::newMainPage
1126          */
1127         public function testNewMainPage() {
1128                 $msgCache = TestingAccessWrapper::newFromClass( MessageCache::class );
1129                 $msgCache->instance = $this->createMock( MessageCache::class );
1130                 $msgCache->instance->method( 'get' )->willReturn( 'Foresheet' );
1131                 $msgCache->instance->method( 'transform' )->willReturn( 'Foresheet' );
1132
1133                 $this->assertSame(
1134                         'Foresheet',
1135                         Title::newMainPage()->getText()
1136                 );
1137         }
1138
1139         /**
1140          * @covers Title::newMainPage
1141          */
1142         public function testNewMainPageWithLocal() {
1143                 $local = $this->createMock( MessageLocalizer::class );
1144                 $local->method( 'msg' )->willReturn( new RawMessage( 'Prime Article' ) );
1145
1146                 $this->assertSame(
1147                         'Prime Article',
1148                         Title::newMainPage( $local )->getText()
1149                 );
1150         }
1151 }