tests/phpunit/includes/GlobalFunctions/GlobalTest.php

   1 <?php
   2
   3 /**
   4  * @group Database
   5  * @group GlobalFunctions
   6  */
   7 class GlobalTest extends MediaWikiTestCase {
   8         protected function setUp() {
   9                 parent::setUp();
  10
  11                 $readOnlyFile = $this->getNewTempFile();
  12                 unlink( $readOnlyFile );
  13
  14                 $this->setMwGlobals( [
  15                         'wgReadOnlyFile' => $readOnlyFile,
  16                         'wgUrlProtocols' => [
  17                                 'http://',
  18                                 'https://',
  19                                 'mailto:',
  20                                 '//',
  21                                 'file://', # Non-default
  22                         ],
  23                 ] );
  24         }
  25
  26         /**
  27          * @dataProvider provideForWfArrayDiff2
  28          * @covers ::wfArrayDiff2
  29          */
  30         public function testWfArrayDiff2( $a, $b, $expected ) {
  31                 $this->assertEquals(
  32                         wfArrayDiff2( $a, $b ), $expected
  33                 );
  34         }
  35
  36         // @todo Provide more tests
  37         public static function provideForWfArrayDiff2() {
  38                 // $a $b $expected
  39                 return [
  40                         [
  41                                 [ 'a', 'b' ],
  42                                 [ 'a', 'b' ],
  43                                 [],
  44                         ],
  45                         [
  46                                 [ [ 'a' ], [ 'a', 'b', 'c' ] ],
  47                                 [ [ 'a' ], [ 'a', 'b' ] ],
  48                                 [ 1 => [ 'a', 'b', 'c' ] ],
  49                         ],
  50                 ];
  51         }
  52
  53         /*
  54          * Test cases for random functions could hypothetically fail,
  55          * even though they shouldn't.
  56          */
  57
  58         /**
  59          * @covers ::wfRandom
  60          */
  61         public function testRandom() {
  62                 $this->assertFalse(
  63                         wfRandom() == wfRandom()
  64                 );
  65         }
  66
  67         /**
  68          * @covers ::wfRandomString
  69          */
  70         public function testRandomString() {
  71                 $this->assertFalse(
  72                         wfRandomString() == wfRandomString()
  73                 );
  74                 $this->assertEquals(
  75                         strlen( wfRandomString( 10 ) ), 10
  76                 );
  77                 $this->assertTrue(
  78                         preg_match( '/^[0-9a-f]+$/i', wfRandomString() ) === 1
  79                 );
  80         }
  81
  82         /**
  83          * @covers ::wfUrlencode
  84          */
  85         public function testUrlencode() {
  86                 $this->assertEquals(
  87                         "%E7%89%B9%E5%88%A5:Contributions/Foobar",
  88                         wfUrlencode( "\xE7\x89\xB9\xE5\x88\xA5:Contributions/Foobar" ) );
  89         }
  90
  91         /**
  92          * @covers ::wfExpandIRI
  93          */
  94         public function testExpandIRI() {
  95                 $this->assertEquals(
  96                         "https://te.wikibooks.org/wiki/ఉబుంటు_వాడుకరి_మార్గదర్శని",
  97                         wfExpandIRI( "https://te.wikibooks.org/wiki/"
  98                                 . "%E0%B0%89%E0%B0%AC%E0%B1%81%E0%B0%82%E0%B0%9F%E0%B1%81_"
  99                                 . "%E0%B0%B5%E0%B0%BE%E0%B0%A1%E0%B1%81%E0%B0%95%E0%B0%B0%E0%B0%BF_"
 100                                 . "%E0%B0%AE%E0%B0%BE%E0%B0%B0%E0%B1%8D%E0%B0%97%E0%B0%A6%E0%B0%B0"
 101                                 . "%E0%B1%8D%E0%B0%B6%E0%B0%A8%E0%B0%BF" ) );
 102         }
 103
 104         /**
 105          * Intended to cover the relevant bits of ServiceWiring.php, as well as GlobalFunctions.php
 106          * @covers ::wfReadOnly
 107          */
 108         public function testReadOnlyEmpty() {
 109                 global $wgReadOnly;
 110                 $wgReadOnly = null;
 111
 112                 MediaWiki\MediaWikiServices::getInstance()->getReadOnlyMode()->clearCache();
 113                 $this->assertFalse( wfReadOnly() );
 114                 $this->assertFalse( wfReadOnly() );
 115         }
 116
 117         /**
 118          * Intended to cover the relevant bits of ServiceWiring.php, as well as GlobalFunctions.php
 119          * @covers ::wfReadOnly
 120          */
 121         public function testReadOnlySet() {
 122                 global $wgReadOnly, $wgReadOnlyFile;
 123
 124                 $readOnlyMode = MediaWiki\MediaWikiServices::getInstance()->getReadOnlyMode();
 125                 $readOnlyMode->clearCache();
 126
 127                 $f = fopen( $wgReadOnlyFile, "wt" );
 128                 fwrite( $f, 'Message' );
 129                 fclose( $f );
 130                 $wgReadOnly = null; # Check on $wgReadOnlyFile
 131
 132                 $this->assertTrue( wfReadOnly() );
 133                 $this->assertTrue( wfReadOnly() ); # Check cached
 134
 135                 unlink( $wgReadOnlyFile );
 136                 $readOnlyMode->clearCache();
 137                 $this->assertFalse( wfReadOnly() );
 138                 $this->assertFalse( wfReadOnly() );
 139         }
 140
 141         /**
 142          * This behaviour could probably be deprecated. Several extensions rely on it as of 1.29.
 143          * @covers ::wfReadOnlyReason
 144          */
 145         public function testReadOnlyGlobalChange() {
 146                 $this->assertFalse( wfReadOnlyReason() );
 147                 $this->setMwGlobals( [
 148                         'wgReadOnly' => 'reason'
 149                 ] );
 150                 $this->assertSame( 'reason', wfReadOnlyReason() );
 151         }
 152
 153         public static function provideArrayToCGI() {
 154                 return [
 155                         [ [], '' ], // empty
 156                         [ [ 'foo' => 'bar' ], 'foo=bar' ], // string test
 157                         [ [ 'foo' => '' ], 'foo=' ], // empty string test
 158                         [ [ 'foo' => 1 ], 'foo=1' ], // number test
 159                         [ [ 'foo' => true ], 'foo=1' ], // true test
 160                         [ [ 'foo' => false ], '' ], // false test
 161                         [ [ 'foo' => null ], '' ], // null test
 162                         [ [ 'foo' => 'A&B=5+6@!"\'' ], 'foo=A%26B%3D5%2B6%40%21%22%27' ], // urlencoding test
 163                         [
 164                                 [ 'foo' => 'bar', 'baz' => 'is', 'asdf' => 'qwerty' ],
 165                                 'foo=bar&baz=is&asdf=qwerty'
 166                         ], // multi-item test
 167                         [ [ 'foo' => [ 'bar' => 'baz' ] ], 'foo%5Bbar%5D=baz' ],
 168                         [
 169                                 [ 'foo' => [ 'bar' => 'baz', 'qwerty' => 'asdf' ] ],
 170                                 'foo%5Bbar%5D=baz&foo%5Bqwerty%5D=asdf'
 171                         ],
 172                         [ [ 'foo' => [ 'bar', 'baz' ] ], 'foo%5B0%5D=bar&foo%5B1%5D=baz' ],
 173                         [
 174                                 [ 'foo' => [ 'bar' => [ 'bar' => 'baz' ] ] ],
 175                                 'foo%5Bbar%5D%5Bbar%5D=baz'
 176                         ],
 177                 ];
 178         }
 179
 180         /**
 181          * @dataProvider provideArrayToCGI
 182          * @covers ::wfArrayToCgi
 183          */
 184         public function testArrayToCGI( $array, $result ) {
 185                 $this->assertEquals( $result, wfArrayToCgi( $array ) );
 186         }
 187
 188         /**
 189          * @covers ::wfArrayToCgi
 190          */
 191         public function testArrayToCGI2() {
 192                 $this->assertEquals(
 193                         "baz=bar&foo=bar",
 194                         wfArrayToCgi(
 195                                 [ 'baz' => 'bar' ],
 196                                 [ 'foo' => 'bar', 'baz' => 'overridden value' ] ) );
 197         }
 198
 199         public static function provideCgiToArray() {
 200                 return [
 201                         [ '', [] ], // empty
 202                         [ 'foo=bar', [ 'foo' => 'bar' ] ], // string
 203                         [ 'foo=', [ 'foo' => '' ] ], // empty string
 204                         [ 'foo', [ 'foo' => '' ] ], // missing =
 205                         [ 'foo=bar&qwerty=asdf', [ 'foo' => 'bar', 'qwerty' => 'asdf' ] ], // multiple value
 206                         [ 'foo=A%26B%3D5%2B6%40%21%22%27', [ 'foo' => 'A&B=5+6@!"\'' ] ], // urldecoding test
 207                         [ 'foo%5Bbar%5D=baz', [ 'foo' => [ 'bar' => 'baz' ] ] ],
 208                         [
 209                                 'foo%5Bbar%5D=baz&foo%5Bqwerty%5D=asdf',
 210                                 [ 'foo' => [ 'bar' => 'baz', 'qwerty' => 'asdf' ] ]
 211                         ],
 212                         [ 'foo%5B0%5D=bar&foo%5B1%5D=baz', [ 'foo' => [ 0 => 'bar', 1 => 'baz' ] ] ],
 213                         [
 214                                 'foo%5Bbar%5D%5Bbar%5D=baz',
 215                                 [ 'foo' => [ 'bar' => [ 'bar' => 'baz' ] ] ]
 216                         ],
 217                 ];
 218         }
 219
 220         /**
 221          * @dataProvider provideCgiToArray
 222          * @covers ::wfCgiToArray
 223          */
 224         public function testCgiToArray( $cgi, $result ) {
 225                 $this->assertEquals( $result, wfCgiToArray( $cgi ) );
 226         }
 227
 228         public static function provideCgiRoundTrip() {
 229                 return [
 230                         [ '' ],
 231                         [ 'foo=bar' ],
 232                         [ 'foo=' ],
 233                         [ 'foo=bar&baz=biz' ],
 234                         [ 'foo=A%26B%3D5%2B6%40%21%22%27' ],
 235                         [ 'foo%5Bbar%5D=baz' ],
 236                         [ 'foo%5B0%5D=bar&foo%5B1%5D=baz' ],
 237                         [ 'foo%5Bbar%5D%5Bbar%5D=baz' ],
 238                 ];
 239         }
 240
 241         /**
 242          * @dataProvider provideCgiRoundTrip
 243          * @covers ::wfArrayToCgi
 244          */
 245         public function testCgiRoundTrip( $cgi ) {
 246                 $this->assertEquals( $cgi, wfArrayToCgi( wfCgiToArray( $cgi ) ) );
 247         }
 248
 249         /**
 250          * @covers ::mimeTypeMatch
 251          */
 252         public function testMimeTypeMatch() {
 253                 $this->assertEquals(
 254                         'text/html',
 255                         mimeTypeMatch( 'text/html',
 256                                 [ 'application/xhtml+xml' => 1.0,
 257                                         'text/html' => 0.7,
 258                                         'text/plain' => 0.3 ] ) );
 259                 $this->assertEquals(
 260                         'text/*',
 261                         mimeTypeMatch( 'text/html',
 262                                 [ 'image/*' => 1.0,
 263                                         'text/*' => 0.5 ] ) );
 264                 $this->assertEquals(
 265                         '*/*',
 266                         mimeTypeMatch( 'text/html',
 267                                 [ '*/*' => 1.0 ] ) );
 268                 $this->assertNull(
 269                         mimeTypeMatch( 'text/html',
 270                                 [ 'image/png' => 1.0,
 271                                         'image/svg+xml' => 0.5 ] ) );
 272         }
 273
 274         /**
 275          * @covers ::wfNegotiateType
 276          */
 277         public function testNegotiateType() {
 278                 $this->assertEquals(
 279                         'text/html',
 280                         wfNegotiateType(
 281                                 [ 'application/xhtml+xml' => 1.0,
 282                                         'text/html' => 0.7,
 283                                         'text/plain' => 0.5,
 284                                         'text/*' => 0.2 ],
 285                                 [ 'text/html' => 1.0 ] ) );
 286                 $this->assertEquals(
 287                         'application/xhtml+xml',
 288                         wfNegotiateType(
 289                                 [ 'application/xhtml+xml' => 1.0,
 290                                         'text/html' => 0.7,
 291                                         'text/plain' => 0.5,
 292                                         'text/*' => 0.2 ],
 293                                 [ 'application/xhtml+xml' => 1.0,
 294                                         'text/html' => 0.5 ] ) );
 295                 $this->assertEquals(
 296                         'text/html',
 297                         wfNegotiateType(
 298                                 [ 'text/html' => 1.0,
 299                                         'text/plain' => 0.5,
 300                                         'text/*' => 0.5,
 301                                         'application/xhtml+xml' => 0.2 ],
 302                                 [ 'application/xhtml+xml' => 1.0,
 303                                         'text/html' => 0.5 ] ) );
 304                 $this->assertEquals(
 305                         'text/html',
 306                         wfNegotiateType(
 307                                 [ 'text/*' => 1.0,
 308                                         'image/*' => 0.7,
 309                                         '*/*' => 0.3 ],
 310                                 [ 'application/xhtml+xml' => 1.0,
 311                                         'text/html' => 0.5 ] ) );
 312                 $this->assertNull(
 313                         wfNegotiateType(
 314                                 [ 'text/*' => 1.0 ],
 315                                 [ 'application/xhtml+xml' => 1.0 ] ) );
 316         }
 317
 318         /**
 319          * @covers ::wfDebug
 320          * @covers ::wfDebugMem
 321          */
 322         public function testDebugFunctionTest() {
 323                 $debugLogFile = $this->getNewTempFile();
 324
 325                 $this->setMwGlobals( [
 326                         'wgDebugLogFile' => $debugLogFile,
 327                         #  @todo FIXME: $wgDebugTimestamps should be tested
 328                         'wgDebugTimestamps' => false
 329                 ] );
 330
 331                 wfDebug( "This is a normal string" );
 332                 $this->assertEquals( "This is a normal string\n", file_get_contents( $debugLogFile ) );
 333                 unlink( $debugLogFile );
 334
 335                 wfDebug( "This is nöt an ASCII string" );
 336                 $this->assertEquals( "This is nöt an ASCII string\n", file_get_contents( $debugLogFile ) );
 337                 unlink( $debugLogFile );
 338
 339                 wfDebug( "\00305This has böth UTF and control chars\003" );
 340                 $this->assertEquals(
 341                         " 05This has böth UTF and control chars \n",
 342                         file_get_contents( $debugLogFile )
 343                 );
 344                 unlink( $debugLogFile );
 345
 346                 wfDebugMem();
 347                 $this->assertGreaterThan(
 348                         1000,
 349                         preg_replace( '/\D/', '', file_get_contents( $debugLogFile ) )
 350                 );
 351                 unlink( $debugLogFile );
 352
 353                 wfDebugMem( true );
 354                 $this->assertGreaterThan(
 355                         1000000,
 356                         preg_replace( '/\D/', '', file_get_contents( $debugLogFile ) )
 357                 );
 358                 unlink( $debugLogFile );
 359         }
 360
 361         /**
 362          * @covers ::wfClientAcceptsGzip
 363          */
 364         public function testClientAcceptsGzipTest() {
 365                 $settings = [
 366                         'gzip' => true,
 367                         'bzip' => false,
 368                         '*' => false,
 369                         'compress, gzip' => true,
 370                         'gzip;q=1.0' => true,
 371                         'foozip' => false,
 372                         'foo*zip' => false,
 373                         'gzip;q=abcde' => true, // is this REALLY valid?
 374                         'gzip;q=12345678.9' => true,
 375                         ' gzip' => true,
 376                 ];
 377
 378                 if ( isset( $_SERVER['HTTP_ACCEPT_ENCODING'] ) ) {
 379                         $old_server_setting = $_SERVER['HTTP_ACCEPT_ENCODING'];
 380                 }
 381
 382                 foreach ( $settings as $encoding => $expect ) {
 383                         $_SERVER['HTTP_ACCEPT_ENCODING'] = $encoding;
 384
 385                         $this->assertEquals( $expect, wfClientAcceptsGzip( true ),
 386                                 "'$encoding' => " . wfBoolToStr( $expect ) );
 387                 }
 388
 389                 if ( isset( $old_server_setting ) ) {
 390                         $_SERVER['HTTP_ACCEPT_ENCODING'] = $old_server_setting;
 391                 }
 392         }
 393
 394         /**
 395          * @covers ::wfPercent
 396          */
 397         public function testWfPercentTest() {
 398                 $pcts = [
 399                         [ 6 / 7, '0.86%', 2, false ],
 400                         [ 3 / 3, '1%' ],
 401                         [ 22 / 7, '3.14286%', 5 ],
 402                         [ 3 / 6, '0.5%' ],
 403                         [ 1 / 3, '0%', 0 ],
 404                         [ 10 / 3, '0%', -1 ],
 405                         [ 3 / 4 / 5, '0.1%', 1 ],
 406                         [ 6 / 7 * 8, '6.8571428571%', 10 ],
 407                 ];
 408
 409                 foreach ( $pcts as $pct ) {
 410                         if ( !isset( $pct[2] ) ) {
 411                                 $pct[2] = 2;
 412                         }
 413                         if ( !isset( $pct[3] ) ) {
 414                                 $pct[3] = true;
 415                         }
 416
 417                         $this->assertEquals( wfPercent( $pct[0], $pct[2], $pct[3] ), $pct[1], $pct[1] );
 418                 }
 419         }
 420
 421         /**
 422          * test @see wfShorthandToInteger()
 423          * @dataProvider provideShorthand
 424          * @covers ::wfShorthandToInteger
 425          */
 426         public function testWfShorthandToInteger( $shorthand, $expected ) {
 427                 $this->assertEquals( $expected,
 428                         wfShorthandToInteger( $shorthand )
 429                 );
 430         }
 431
 432         public static function provideShorthand() {
 433                 // Syntax: [ shorthand, expected integer ]
 434                 return [
 435                         # Null, empty ...
 436                         [ '', -1 ],
 437                         [ '  ', -1 ],
 438                         [ null, -1 ],
 439
 440                         # Failures returns 0 :(
 441                         [ 'ABCDEFG', 0 ],
 442                         [ 'Ak', 0 ],
 443
 444                         # Int, strings with spaces
 445                         [ 1, 1 ],
 446                         [ ' 1 ', 1 ],
 447                         [ 1023, 1023 ],
 448                         [ ' 1023 ', 1023 ],
 449
 450                         # kilo, Mega, Giga
 451                         [ '1k', 1024 ],
 452                         [ '1K', 1024 ],
 453                         [ '1m', 1024 * 1024 ],
 454                         [ '1M', 1024 * 1024 ],
 455                         [ '1g', 1024 * 1024 * 1024 ],
 456                         [ '1G', 1024 * 1024 * 1024 ],
 457
 458                         # Negatives
 459                         [ -1, -1 ],
 460                         [ -500, -500 ],
 461                         [ '-500', -500 ],
 462                         [ '-1k', -1024 ],
 463
 464                         # Zeroes
 465                         [ '0', 0 ],
 466                         [ '0k', 0 ],
 467                         [ '0M', 0 ],
 468                         [ '0G', 0 ],
 469                         [ '-0', 0 ],
 470                         [ '-0k', 0 ],
 471                         [ '-0M', 0 ],
 472                         [ '-0G', 0 ],
 473                 ];
 474         }
 475
 476         /**
 477          * @covers ::wfMerge
 478          */
 479         public function testMerge_worksWithLessParameters() {
 480                 $this->markTestSkippedIfNoDiff3();
 481
 482                 $mergedText = null;
 483                 $successfulMerge = wfMerge( "old1\n\nold2", "old1\n\nnew2", "new1\n\nold2", $mergedText );
 484
 485                 $mergedText = null;
 486                 $conflictingMerge = wfMerge( 'old', 'old and mine', 'old and yours', $mergedText );
 487
 488                 $this->assertEquals( true, $successfulMerge );
 489                 $this->assertEquals( false, $conflictingMerge );
 490         }
 491
 492         /**
 493          * @param string $old Text as it was in the database
 494          * @param string $mine Text submitted while user was editing
 495          * @param string $yours Text submitted by the user
 496          * @param bool $expectedMergeResult Whether the merge should be a success
 497          * @param string $expectedText Text after merge has been completed
 498          * @param string $expectedMergeAttemptResult Diff3 output if conflicts occur
 499          *
 500          * @dataProvider provideMerge()
 501          * @group medium
 502          * @covers ::wfMerge
 503          */
 504         public function testMerge( $old, $mine, $yours, $expectedMergeResult, $expectedText,
 505                                                            $expectedMergeAttemptResult ) {
 506                 $this->markTestSkippedIfNoDiff3();
 507
 508                 $mergedText = null;
 509                 $attemptMergeResult = null;
 510                 $isMerged = wfMerge( $old, $mine, $yours, $mergedText, $mergeAttemptResult );
 511
 512                 $msg = 'Merge should be a ';
 513                 $msg .= $expectedMergeResult ? 'success' : 'failure';
 514                 $this->assertEquals( $expectedMergeResult, $isMerged, $msg );
 515                 $this->assertEquals( $expectedMergeAttemptResult, $mergeAttemptResult );
 516
 517                 if ( $isMerged ) {
 518                         // Verify the merged text
 519                         $this->assertEquals( $expectedText, $mergedText,
 520                                 'is merged text as expected?' );
 521                 }
 522         }
 523
 524         public static function provideMerge() {
 525                 $EXPECT_MERGE_SUCCESS = true;
 526                 $EXPECT_MERGE_FAILURE = false;
 527
 528                 return [
 529                         // #0: clean merge
 530                         [
 531                                 // old:
 532                                 "one one one\n" . // trimmed
 533                                         "\n" .
 534                                         "two two two",
 535
 536                                 // mine:
 537                                 "one one one ONE ONE\n" .
 538                                         "\n" .
 539                                         "two two two\n", // with tailing whitespace
 540
 541                                 // yours:
 542                                 "one one one\n" .
 543                                         "\n" .
 544                                         "two two TWO TWO", // trimmed
 545
 546                                 // ok:
 547                                 $EXPECT_MERGE_SUCCESS,
 548
 549                                 // result:
 550                                 "one one one ONE ONE\n" .
 551                                         "\n" .
 552                                         "two two TWO TWO\n", // note: will always end in a newline
 553
 554                                 // mergeAttemptResult:
 555                                 "",
 556                         ],
 557
 558                         // #1: conflict, fail
 559                         [
 560                                 // old:
 561                                 "one one one", // trimmed
 562
 563                                 // mine:
 564                                 "one one one ONE ONE\n" .
 565                                         "\n" .
 566                                         "bla bla\n" .
 567                                         "\n", // with tailing whitespace
 568
 569                                 // yours:
 570                                 "one one one\n" .
 571                                         "\n" .
 572                                         "two two", // trimmed
 573
 574                                 $EXPECT_MERGE_FAILURE,
 575
 576                                 // result:
 577                                 null,
 578
 579                                 // mergeAttemptResult:
 580                                 "1,3c\n" .
 581                                 "one one one\n" .
 582                                 "\n" .
 583                                 "two two\n" .
 584                                 ".\n",
 585                         ],
 586                 ];
 587         }
 588
 589         /**
 590          * @dataProvider provideMakeUrlIndexes()
 591          * @covers ::wfMakeUrlIndexes
 592          */
 593         public function testMakeUrlIndexes( $url, $expected ) {
 594                 $index = wfMakeUrlIndexes( $url );
 595                 $this->assertEquals( $expected, $index, "wfMakeUrlIndexes(\"$url\")" );
 596         }
 597
 598         public static function provideMakeUrlIndexes() {
 599                 return [
 600                         // Testcase for T30627
 601                         [
 602                                 'https://example.org/test.cgi?id=12345',
 603                                 [ 'https://org.example./test.cgi?id=12345' ]
 604                         ],
 605                         [
 606                                 // mailtos are handled special
 607                                 // is this really right though? that final . probably belongs earlier?
 608                                 'mailto:wiki@wikimedia.org',
 609                                 [ 'mailto:org.wikimedia@wiki.' ]
 610                         ],
 611
 612                         // file URL cases per T30627...
 613                         [
 614                                 // three slashes: local filesystem path Unix-style
 615                                 'file:///whatever/you/like.txt',
 616                                 [ 'file://./whatever/you/like.txt' ]
 617                         ],
 618                         [
 619                                 // three slashes: local filesystem path Windows-style
 620                                 'file:///c:/whatever/you/like.txt',
 621                                 [ 'file://./c:/whatever/you/like.txt' ]
 622                         ],
 623                         [
 624                                 // two slashes: UNC filesystem path Windows-style
 625                                 'file://intranet/whatever/you/like.txt',
 626                                 [ 'file://intranet./whatever/you/like.txt' ]
 627                         ],
 628                         // Multiple-slash cases that can sorta work on Mozilla
 629                         // if you hack it just right are kinda pathological,
 630                         // and unreliable cross-platform or on IE which means they're
 631                         // unlikely to appear on intranets.
 632                         // Those will survive the algorithm but with results that
 633                         // are less consistent.
 634
 635                         // protocol-relative URL cases per T31854...
 636                         [
 637                                 '//example.org/test.cgi?id=12345',
 638                                 [
 639                                         'http://org.example./test.cgi?id=12345',
 640                                         'https://org.example./test.cgi?id=12345'
 641                                 ]
 642                         ],
 643                 ];
 644         }
 645
 646         /**
 647          * @dataProvider provideWfMatchesDomainList
 648          * @covers ::wfMatchesDomainList
 649          */
 650         public function testWfMatchesDomainList( $url, $domains, $expected, $description ) {
 651                 $actual = wfMatchesDomainList( $url, $domains );
 652                 $this->assertEquals( $expected, $actual, $description );
 653         }
 654
 655         public static function provideWfMatchesDomainList() {
 656                 $a = [];
 657                 $protocols = [ 'HTTP' => 'http:', 'HTTPS' => 'https:', 'protocol-relative' => '' ];
 658                 foreach ( $protocols as $pDesc => $p ) {
 659                         $a = array_merge( $a, [
 660                                 [
 661                                         "$p//www.example.com",
 662                                         [],
 663                                         false,
 664                                         "No matches for empty domains array, $pDesc URL"
 665                                 ],
 666                                 [
 667                                         "$p//www.example.com",
 668                                         [ 'www.example.com' ],
 669                                         true,
 670                                         "Exact match in domains array, $pDesc URL"
 671                                 ],
 672                                 [
 673                                         "$p//www.example.com",
 674                                         [ 'example.com' ],
 675                                         true,
 676                                         "Match without subdomain in domains array, $pDesc URL"
 677                                 ],
 678                                 [
 679                                         "$p//www.example2.com",
 680                                         [ 'www.example.com', 'www.example2.com', 'www.example3.com' ],
 681                                         true,
 682                                         "Exact match with other domains in array, $pDesc URL"
 683                                 ],
 684                                 [
 685                                         "$p//www.example2.com",
 686                                         [ 'example.com', 'example2.com', 'example3,com' ],
 687                                         true,
 688                                         "Match without subdomain with other domains in array, $pDesc URL"
 689                                 ],
 690                                 [
 691                                         "$p//www.example4.com",
 692                                         [ 'example.com', 'example2.com', 'example3,com' ],
 693                                         false,
 694                                         "Domain not in array, $pDesc URL"
 695                                 ],
 696                                 [
 697                                         "$p//nds-nl.wikipedia.org",
 698                                         [ 'nl.wikipedia.org' ],
 699                                         false,
 700                                         "Non-matching substring of domain, $pDesc URL"
 701                                 ],
 702                         ] );
 703                 }
 704
 705                 return $a;
 706         }
 707
 708         /**
 709          * @covers ::wfMkdirParents
 710          */
 711         public function testWfMkdirParents() {
 712                 // Should not return true if file exists instead of directory
 713                 $fname = $this->getNewTempFile();
 714                 Wikimedia\suppressWarnings();
 715                 $ok = wfMkdirParents( $fname );
 716                 Wikimedia\restoreWarnings();
 717                 $this->assertFalse( $ok );
 718         }
 719
 720         /**
 721          * @dataProvider provideWfShellWikiCmdList
 722          * @covers ::wfShellWikiCmd
 723          */
 724         public function testWfShellWikiCmd( $script, $parameters, $options,
 725                 $expected, $description
 726         ) {
 727                 if ( wfIsWindows() ) {
 728                         // Approximation that's good enough for our purposes just now
 729                         $expected = str_replace( "'", '"', $expected );
 730                 }
 731                 $actual = wfShellWikiCmd( $script, $parameters, $options );
 732                 $this->assertEquals( $expected, $actual, $description );
 733         }
 734
 735         public function wfWikiID() {
 736                 $this->setMwGlobals( [
 737                         'wgDBname' => 'example',
 738                         'wgDBprefix' => '',
 739                 ] );
 740                 $this->assertEquals(
 741                         wfWikiID(),
 742                         'example'
 743                 );
 744
 745                 $this->setMwGlobals( [
 746                         'wgDBname' => 'example',
 747                         'wgDBprefix' => 'mw_',
 748                 ] );
 749                 $this->assertEquals(
 750                         wfWikiID(),
 751                         'example-mw_'
 752                 );
 753         }
 754
 755         /**
 756          * @covers ::wfMemcKey
 757          */
 758         public function testWfMemcKey() {
 759                 $cache = ObjectCache::getLocalClusterInstance();
 760                 $this->assertEquals(
 761                         $cache->makeKey( 'foo', 123, 'bar' ),
 762                         wfMemcKey( 'foo', 123, 'bar' )
 763                 );
 764         }
 765
 766         /**
 767          * @covers ::wfForeignMemcKey
 768          */
 769         public function testWfForeignMemcKey() {
 770                 $cache = ObjectCache::getLocalClusterInstance();
 771                 $keyspace = $this->readAttribute( $cache, 'keyspace' );
 772                 $this->assertEquals(
 773                         wfForeignMemcKey( $keyspace, '', 'foo', 'bar' ),
 774                         $cache->makeKey( 'foo', 'bar' )
 775                 );
 776         }
 777
 778         /**
 779          * @covers ::wfGlobalCacheKey
 780          */
 781         public function testWfGlobalCacheKey() {
 782                 $cache = ObjectCache::getLocalClusterInstance();
 783                 $this->assertEquals(
 784                         $cache->makeGlobalKey( 'foo', 123, 'bar' ),
 785                         wfGlobalCacheKey( 'foo', 123, 'bar' )
 786                 );
 787         }
 788
 789         public static function provideWfShellWikiCmdList() {
 790                 global $wgPhpCli;
 791
 792                 return [
 793                         [ 'eval.php', [ '--help', '--test' ], [],
 794                                 "'$wgPhpCli' 'eval.php' '--help' '--test'",
 795                                 "Called eval.php --help --test" ],
 796                         [ 'eval.php', [ '--help', '--test space' ], [ 'php' => 'php5' ],
 797                                 "'php5' 'eval.php' '--help' '--test space'",
 798                                 "Called eval.php --help --test with php option" ],
 799                         [ 'eval.php', [ '--help', '--test', 'X' ], [ 'wrapper' => 'MWScript.php' ],
 800                                 "'$wgPhpCli' 'MWScript.php' 'eval.php' '--help' '--test' 'X'",
 801                                 "Called eval.php --help --test with wrapper option" ],
 802                         [
 803                                 'eval.php',
 804                                 [ '--help', '--test', 'y' ],
 805                                 [ 'php' => 'php5', 'wrapper' => 'MWScript.php' ],
 806                                 "'php5' 'MWScript.php' 'eval.php' '--help' '--test' 'y'",
 807                                 "Called eval.php --help --test with wrapper and php option"
 808                         ],
 809                 ];
 810         }
 811         /* @todo many more! */
 812 }