tests/phpunit/includes/TitleTest.php

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