tests/phpunit/includes/resourceloader/ResourceLoaderTest.php

   1 <?php
   2
   3 use Wikimedia\TestingAccessWrapper;
   4
   5 class ResourceLoaderTest extends ResourceLoaderTestCase {
   6
   7         protected function setUp() {
   8                 parent::setUp();
   9
  10                 $this->setMwGlobals( [
  11                         'wgShowExceptionDetails' => true,
  12                 ] );
  13         }
  14
  15         /**
  16          * Ensure the ResourceLoaderRegisterModules hook is called.
  17          *
  18          * @covers ResourceLoader::__construct
  19          */
  20         public function testConstructRegistrationHook() {
  21                 $resourceLoaderRegisterModulesHook = false;
  22
  23                 $this->setMwGlobals( 'wgHooks', [
  24                         'ResourceLoaderRegisterModules' => [
  25                                 function ( &$resourceLoader ) use ( &$resourceLoaderRegisterModulesHook ) {
  26                                         $resourceLoaderRegisterModulesHook = true;
  27                                 }
  28                         ]
  29                 ] );
  30
  31                 $unused = new ResourceLoader();
  32                 $this->assertTrue(
  33                         $resourceLoaderRegisterModulesHook,
  34                         'Hook ResourceLoaderRegisterModules called'
  35                 );
  36         }
  37
  38         /**
  39          * @covers ResourceLoader::register
  40          * @covers ResourceLoader::getModule
  41          */
  42         public function testRegisterValidObject() {
  43                 $module = new ResourceLoaderTestModule();
  44                 $resourceLoader = new EmptyResourceLoader();
  45                 $resourceLoader->register( 'test', $module );
  46                 $this->assertEquals( $module, $resourceLoader->getModule( 'test' ) );
  47         }
  48
  49         /**
  50          * @covers ResourceLoader::register
  51          * @covers ResourceLoader::getModule
  52          */
  53         public function testRegisterValidArray() {
  54                 $module = new ResourceLoaderTestModule();
  55                 $resourceLoader = new EmptyResourceLoader();
  56                 // Covers case of register() setting $rl->moduleInfos,
  57                 // but $rl->modules lazy-populated by getModule()
  58                 $resourceLoader->register( 'test', [ 'object' => $module ] );
  59                 $this->assertEquals( $module, $resourceLoader->getModule( 'test' ) );
  60         }
  61
  62         /**
  63          * @covers ResourceLoader::register
  64          */
  65         public function testRegisterEmptyString() {
  66                 $module = new ResourceLoaderTestModule();
  67                 $resourceLoader = new EmptyResourceLoader();
  68                 $resourceLoader->register( '', $module );
  69                 $this->assertEquals( $module, $resourceLoader->getModule( '' ) );
  70         }
  71
  72         /**
  73          * @covers ResourceLoader::register
  74          */
  75         public function testRegisterInvalidName() {
  76                 $resourceLoader = new EmptyResourceLoader();
  77                 $this->setExpectedException( MWException::class, "name 'test!invalid' is invalid" );
  78                 $resourceLoader->register( 'test!invalid', new ResourceLoaderTestModule() );
  79         }
  80
  81         /**
  82          * @covers ResourceLoader::register
  83          */
  84         public function testRegisterInvalidType() {
  85                 $resourceLoader = new EmptyResourceLoader();
  86                 $this->setExpectedException( MWException::class, 'ResourceLoader module info type error' );
  87                 $resourceLoader->register( 'test', new stdClass() );
  88         }
  89
  90         /**
  91          * @covers ResourceLoader::register
  92          */
  93         public function testRegisterDuplicate() {
  94                 $logger = $this->getMockBuilder( Psr\Log\LoggerInterface::class )->getMock();
  95                 $logger->expects( $this->once() )
  96                         ->method( 'warning' );
  97                 $resourceLoader = new EmptyResourceLoader( null, $logger );
  98
  99                 $module1 = new ResourceLoaderTestModule();
 100                 $module2 = new ResourceLoaderTestModule();
 101                 $resourceLoader->register( 'test', $module1 );
 102                 $resourceLoader->register( 'test', $module2 );
 103                 $this->assertSame( $module2, $resourceLoader->getModule( 'test' ) );
 104         }
 105
 106         /**
 107          * @covers ResourceLoader::getModuleNames
 108          */
 109         public function testGetModuleNames() {
 110                 // Use an empty one so that core and extension modules don't get in.
 111                 $resourceLoader = new EmptyResourceLoader();
 112                 $resourceLoader->register( 'test.foo', new ResourceLoaderTestModule() );
 113                 $resourceLoader->register( 'test.bar', new ResourceLoaderTestModule() );
 114                 $this->assertEquals(
 115                         [ 'test.foo', 'test.bar' ],
 116                         $resourceLoader->getModuleNames()
 117                 );
 118         }
 119
 120         public function provideTestIsFileModule() {
 121                 $fileModuleObj = $this->getMockBuilder( ResourceLoaderFileModule::class )
 122                         ->disableOriginalConstructor()
 123                         ->getMock();
 124                 return [
 125                         'object' => [ false,
 126                                 new ResourceLoaderTestModule()
 127                         ],
 128                         'FileModule object' => [ false,
 129                                 $fileModuleObj
 130                         ],
 131                         'simple empty' => [ true,
 132                                 []
 133                         ],
 134                         'simple scripts' => [ true,
 135                                 [ 'scripts' => 'example.js' ]
 136                         ],
 137                         'simple scripts, raw and targets' => [ true, [
 138                                 'scripts' => [ 'a.js', 'b.js' ],
 139                                 'raw' => true,
 140                                 'targets' => [ 'desktop', 'mobile' ],
 141                         ] ],
 142                         'FileModule' => [ true,
 143                                 [ 'class' => ResourceLoaderFileModule::class, 'scripts' => 'example.js' ]
 144                         ],
 145                         'TestModule' => [ false,
 146                                 [ 'class' => ResourceLoaderTestModule::class, 'scripts' => 'example.js' ]
 147                         ],
 148                         'SkinModule (FileModule subclass)' => [ true,
 149                                 [ 'class' => ResourceLoaderSkinModule::class, 'scripts' => 'example.js' ]
 150                         ],
 151                         'WikiModule' => [ false, [
 152                                 'class' => ResourceLoaderWikiModule::class,
 153                                 'scripts' => [ 'MediaWiki:Example.js' ],
 154                         ] ],
 155                 ];
 156         }
 157
 158         /**
 159          * @dataProvider provideTestIsFileModule
 160          * @covers ResourceLoader::isFileModule
 161          */
 162         public function testIsFileModule( $expected, $module ) {
 163                 $rl = TestingAccessWrapper::newFromObject( new EmptyResourceLoader() );
 164                 $rl->register( 'test', $module );
 165                 $this->assertSame( $expected, $rl->isFileModule( 'test' ) );
 166         }
 167
 168         /**
 169          * @covers ResourceLoader::isFileModule
 170          */
 171         public function testIsFileModuleUnknown() {
 172                 $rl = TestingAccessWrapper::newFromObject( new EmptyResourceLoader() );
 173                 $this->assertSame( false, $rl->isFileModule( 'unknown' ) );
 174         }
 175
 176         /**
 177          * @covers ResourceLoader::isModuleRegistered
 178          */
 179         public function testIsModuleRegistered() {
 180                 $rl = new EmptyResourceLoader();
 181                 $rl->register( 'test', new ResourceLoaderTestModule() );
 182                 $this->assertTrue( $rl->isModuleRegistered( 'test' ) );
 183                 $this->assertFalse( $rl->isModuleRegistered( 'test.unknown' ) );
 184         }
 185
 186         /**
 187          * @covers ResourceLoader::getModule
 188          */
 189         public function testGetModuleUnknown() {
 190                 $rl = new EmptyResourceLoader();
 191                 $this->assertSame( null, $rl->getModule( 'test' ) );
 192         }
 193
 194         /**
 195          * @covers ResourceLoader::getModule
 196          */
 197         public function testGetModuleClass() {
 198                 $rl = new EmptyResourceLoader();
 199                 $rl->register( 'test', [ 'class' => ResourceLoaderTestModule::class ] );
 200                 $this->assertInstanceOf(
 201                         ResourceLoaderTestModule::class,
 202                         $rl->getModule( 'test' )
 203                 );
 204         }
 205
 206         /**
 207          * @covers ResourceLoader::getModule
 208          */
 209         public function testGetModuleFactory() {
 210                 $factory = function ( array $info ) {
 211                         $this->assertArrayHasKey( 'kitten', $info );
 212                         return new ResourceLoaderTestModule( $info );
 213                 };
 214
 215                 $rl = new EmptyResourceLoader();
 216                 $rl->register( 'test', [ 'factory' => $factory, 'kitten' => 'little ball of fur' ] );
 217                 $this->assertInstanceOf(
 218                         ResourceLoaderTestModule::class,
 219                         $rl->getModule( 'test' )
 220                 );
 221         }
 222
 223         /**
 224          * @covers ResourceLoader::getModule
 225          */
 226         public function testGetModuleClassDefault() {
 227                 $rl = new EmptyResourceLoader();
 228                 $rl->register( 'test', [] );
 229                 $this->assertInstanceOf(
 230                         ResourceLoaderFileModule::class,
 231                         $rl->getModule( 'test' ),
 232                         'Array-style module registrations default to FileModule'
 233                 );
 234         }
 235
 236         /**
 237          * @covers ResourceLoader::getLessCompiler
 238          */
 239         public function testLessImportDirs() {
 240                 $rl = new EmptyResourceLoader();
 241                 $lc = $rl->getLessCompiler( [ 'foo'  => '2px', 'Foo' => '#eeeeee' ] );
 242                 $basePath = dirname( dirname( __DIR__ ) ) . '/data/less';
 243                 $lc->SetImportDirs( [
 244                          "$basePath/common" => '',
 245                 ] );
 246                 $css = $lc->parseFile( "$basePath/module/use-import-dir.less" )->getCss();
 247                 $this->assertStringEqualsFile( "$basePath/module/styles.css", $css );
 248         }
 249
 250         public static function providePackedModules() {
 251                 return [
 252                         [
 253                                 'Example from makePackedModulesString doc comment',
 254                                 [ 'foo.bar', 'foo.baz', 'bar.baz', 'bar.quux' ],
 255                                 'foo.bar,baz|bar.baz,quux',
 256                         ],
 257                         [
 258                                 'Example from expandModuleNames doc comment',
 259                                 [ 'jquery.foo', 'jquery.bar', 'jquery.ui.baz', 'jquery.ui.quux' ],
 260                                 'jquery.foo,bar|jquery.ui.baz,quux',
 261                         ],
 262                         [
 263                                 'Regression fixed in r87497 (7fee86c38e) with dotless names',
 264                                 [ 'foo', 'bar', 'baz' ],
 265                                 'foo,bar,baz',
 266                         ],
 267                         [
 268                                 'Prefixless modules after a prefixed module',
 269                                 [ 'single.module', 'foobar', 'foobaz' ],
 270                                 'single.module|foobar,foobaz',
 271                         ],
 272                         [
 273                                 'Ordering',
 274                                 [ 'foo', 'foo.baz', 'baz.quux', 'foo.bar' ],
 275                                 'foo|foo.baz,bar|baz.quux',
 276                                 [ 'foo', 'foo.baz', 'foo.bar', 'baz.quux' ],
 277                         ]
 278                 ];
 279         }
 280
 281         /**
 282          * @dataProvider providePackedModules
 283          * @covers ResourceLoader::makePackedModulesString
 284          */
 285         public function testMakePackedModulesString( $desc, $modules, $packed ) {
 286                 $this->assertEquals( $packed, ResourceLoader::makePackedModulesString( $modules ), $desc );
 287         }
 288
 289         /**
 290          * @dataProvider providePackedModules
 291          * @covers ResourceLoader::expandModuleNames
 292          */
 293         public function testExpandModuleNames( $desc, $modules, $packed, $unpacked = null ) {
 294                 $this->assertEquals(
 295                         $unpacked ?: $modules,
 296                         ResourceLoader::expandModuleNames( $packed ),
 297                         $desc
 298                 );
 299         }
 300
 301         public static function provideAddSource() {
 302                 return [
 303                         [ 'foowiki', 'https://example.org/w/load.php', 'foowiki' ],
 304                         [ 'foowiki', [ 'loadScript' => 'https://example.org/w/load.php' ], 'foowiki' ],
 305                         [
 306                                 [
 307                                         'foowiki' => 'https://example.org/w/load.php',
 308                                         'bazwiki' => 'https://example.com/w/load.php',
 309                                 ],
 310                                 null,
 311                                 [ 'foowiki', 'bazwiki' ]
 312                         ]
 313                 ];
 314         }
 315
 316         /**
 317          * @dataProvider provideAddSource
 318          * @covers ResourceLoader::addSource
 319          * @covers ResourceLoader::getSources
 320          */
 321         public function testAddSource( $name, $info, $expected ) {
 322                 $rl = new ResourceLoader;
 323                 $rl->addSource( $name, $info );
 324                 if ( is_array( $expected ) ) {
 325                         foreach ( $expected as $source ) {
 326                                 $this->assertArrayHasKey( $source, $rl->getSources() );
 327                         }
 328                 } else {
 329                         $this->assertArrayHasKey( $expected, $rl->getSources() );
 330                 }
 331         }
 332
 333         /**
 334          * @covers ResourceLoader::addSource
 335          */
 336         public function testAddSourceDupe() {
 337                 $rl = new ResourceLoader;
 338                 $this->setExpectedException(
 339                         MWException::class, 'ResourceLoader duplicate source addition error'
 340                 );
 341                 $rl->addSource( 'foo', 'https://example.org/w/load.php' );
 342                 $rl->addSource( 'foo', 'https://example.com/w/load.php' );
 343         }
 344
 345         /**
 346          * @covers ResourceLoader::addSource
 347          */
 348         public function testAddSourceInvalid() {
 349                 $rl = new ResourceLoader;
 350                 $this->setExpectedException( MWException::class, 'with no "loadScript" key' );
 351                 $rl->addSource( 'foo',  [ 'x' => 'https://example.org/w/load.php' ] );
 352         }
 353
 354         public static function provideLoaderImplement() {
 355                 return [
 356                         [ [
 357                                 'title' => 'Implement scripts, styles and messages',
 358
 359                                 'name' => 'test.example',
 360                                 'scripts' => 'mw.example();',
 361                                 'styles' => [ 'css' => [ '.mw-example {}' ] ],
 362                                 'messages' => [ 'example' => '' ],
 363                                 'templates' => [],
 364
 365                                 'expected' => 'mw.loader.implement( "test.example", function ( $, jQuery, require, module ) {
 366 mw.example();
 367 }, {
 368     "css": [
 369         ".mw-example {}"
 370     ]
 371 }, {
 372     "example": ""
 373 } );',
 374                         ] ],
 375                         [ [
 376                                 'title' => 'Implement scripts',
 377
 378                                 'name' => 'test.example',
 379                                 'scripts' => 'mw.example();',
 380                                 'styles' => [],
 381
 382                                 'expected' => 'mw.loader.implement( "test.example", function ( $, jQuery, require, module ) {
 383 mw.example();
 384 } );',
 385                         ] ],
 386                         [ [
 387                                 'title' => 'Implement styles',
 388
 389                                 'name' => 'test.example',
 390                                 'scripts' => [],
 391                                 'styles' => [ 'css' => [ '.mw-example {}' ] ],
 392
 393                                 'expected' => 'mw.loader.implement( "test.example", [], {
 394     "css": [
 395         ".mw-example {}"
 396     ]
 397 } );',
 398                         ] ],
 399                         [ [
 400                                 'title' => 'Implement scripts and messages',
 401
 402                                 'name' => 'test.example',
 403                                 'scripts' => 'mw.example();',
 404                                 'messages' => [ 'example' => '' ],
 405
 406                                 'expected' => 'mw.loader.implement( "test.example", function ( $, jQuery, require, module ) {
 407 mw.example();
 408 }, {}, {
 409     "example": ""
 410 } );',
 411                         ] ],
 412                         [ [
 413                                 'title' => 'Implement scripts and templates',
 414
 415                                 'name' => 'test.example',
 416                                 'scripts' => 'mw.example();',
 417                                 'templates' => [ 'example.html' => '' ],
 418
 419                                 'expected' => 'mw.loader.implement( "test.example", function ( $, jQuery, require, module ) {
 420 mw.example();
 421 }, {}, {}, {
 422     "example.html": ""
 423 } );',
 424                         ] ],
 425                         [ [
 426                                 'title' => 'Implement unwrapped user script',
 427
 428                                 'name' => 'user',
 429                                 'scripts' => 'mw.example( 1 );',
 430                                 'wrap' => false,
 431
 432                                 'expected' => 'mw.loader.implement( "user", "mw.example( 1 );" );',
 433                         ] ],
 434                         [ [
 435                                 'title' => 'Implement multi-file script',
 436
 437                                 'name' => 'test.multifile',
 438                                 'scripts' => [
 439                                         'files' => [
 440                                                 'one.js' => [
 441                                                         'type' => 'script',
 442                                                         'content' => 'mw.example( 1 );',
 443                                                 ],
 444                                                 'two.json' => [
 445                                                         'type' => 'data',
 446                                                         'content' => [ 'n' => 2 ],
 447                                                 ],
 448                                                 'three.js' => [
 449                                                         'type' => 'script',
 450                                                         'content' => 'mw.example( 3 );'
 451                                                 ],
 452                                         ],
 453                                         'main' => 'three.js',
 454                                 ],
 455
 456                                 'expected' => <<<END
 457 mw.loader.implement( "test.multifile", {
 458     "main": "three.js",
 459     "files": {
 460     "one.js": function ( require, module ) {
 461 mw.example( 1 );
 462 },
 463     "two.json": {
 464     "n": 2
 465 },
 466     "three.js": function ( require, module ) {
 467 mw.example( 3 );
 468 }
 469 }
 470 } );
 471 END
 472                         ] ],
 473                 ];
 474         }
 475
 476         /**
 477          * @dataProvider provideLoaderImplement
 478          * @covers ResourceLoader::makeLoaderImplementScript
 479          * @covers ResourceLoader::trimArray
 480          */
 481         public function testMakeLoaderImplementScript( $case ) {
 482                 $case += [
 483                         'wrap' => true,
 484                         'styles' => [], 'templates' => [], 'messages' => new XmlJsCode( '{}' ), 'packageFiles' => [],
 485                 ];
 486                 ResourceLoader::clearCache();
 487                 $this->setMwGlobals( 'wgResourceLoaderDebug', true );
 488
 489                 $rl = TestingAccessWrapper::newFromClass( ResourceLoader::class );
 490                 $this->assertEquals(
 491                         $case['expected'],
 492                         $rl->makeLoaderImplementScript(
 493                                 $case['name'],
 494                                 ( $case['wrap'] && is_string( $case['scripts'] ) )
 495                                         ? new XmlJsCode( $case['scripts'] )
 496                                         : $case['scripts'],
 497                                 $case['styles'],
 498                                 $case['messages'],
 499                                 $case['templates'],
 500                                 $case['packageFiles']
 501                         )
 502                 );
 503         }
 504
 505         /**
 506          * @covers ResourceLoader::makeLoaderImplementScript
 507          */
 508         public function testMakeLoaderImplementScriptInvalid() {
 509                 $this->setExpectedException( MWException::class, 'Invalid scripts error' );
 510                 $rl = TestingAccessWrapper::newFromClass( ResourceLoader::class );
 511                 $rl->makeLoaderImplementScript(
 512                         'test', // name
 513                         123, // scripts
 514                         null, // styles
 515                         null, // messages
 516                         null, // templates
 517                         null // package files
 518                 );
 519         }
 520
 521         /**
 522          * @covers ResourceLoader::makeLoaderRegisterScript
 523          */
 524         public function testMakeLoaderRegisterScript() {
 525                 $this->assertEquals(
 526                         'mw.loader.register( [
 527     [
 528         "test.name",
 529         "1234567"
 530     ]
 531 ] );',
 532                         ResourceLoader::makeLoaderRegisterScript( [
 533                                 [ 'test.name', '1234567' ],
 534                         ] ),
 535                         'Nested array parameter'
 536                 );
 537
 538                 $this->assertEquals(
 539                         'mw.loader.register( [
 540     [
 541         "test.foo",
 542         "100"
 543     ],
 544     [
 545         "test.bar",
 546         "200",
 547         [
 548             "test.unknown"
 549         ]
 550     ],
 551     [
 552         "test.baz",
 553         "300",
 554         [
 555             3,
 556             0
 557         ]
 558     ],
 559     [
 560         "test.quux",
 561         "400",
 562         [],
 563         null,
 564         null,
 565         "return true;"
 566     ]
 567 ] );',
 568                         ResourceLoader::makeLoaderRegisterScript( [
 569                                 [ 'test.foo', '100' , [], null, null ],
 570                                 [ 'test.bar', '200', [ 'test.unknown' ], null ],
 571                                 [ 'test.baz', '300', [ 'test.quux', 'test.foo' ], null ],
 572                                 [ 'test.quux', '400', [], null, null, 'return true;' ],
 573                         ] ),
 574                         'Compact dependency indexes'
 575                 );
 576         }
 577
 578         /**
 579          * @covers ResourceLoader::makeLoaderSourcesScript
 580          */
 581         public function testMakeLoaderSourcesScript() {
 582                 $this->assertEquals(
 583                         'mw.loader.addSource( {
 584     "local": "/w/load.php"
 585 } );',
 586                         ResourceLoader::makeLoaderSourcesScript( 'local', '/w/load.php' )
 587                 );
 588                 $this->assertEquals(
 589                         'mw.loader.addSource( {
 590     "local": "/w/load.php"
 591 } );',
 592                         ResourceLoader::makeLoaderSourcesScript( [ 'local' => '/w/load.php' ] )
 593                 );
 594                 $this->assertEquals(
 595                         'mw.loader.addSource( {
 596     "local": "/w/load.php",
 597     "example": "https://example.org/w/load.php"
 598 } );',
 599                         ResourceLoader::makeLoaderSourcesScript( [
 600                                 'local' => '/w/load.php',
 601                                 'example' => 'https://example.org/w/load.php'
 602                         ] )
 603                 );
 604                 $this->assertEquals(
 605                         'mw.loader.addSource( [] );',
 606                         ResourceLoader::makeLoaderSourcesScript( [] )
 607                 );
 608         }
 609
 610         private static function fakeSources() {
 611                 return [
 612                         'examplewiki' => [
 613                                 'loadScript' => '//example.org/w/load.php',
 614                                 'apiScript' => '//example.org/w/api.php',
 615                         ],
 616                         'example2wiki' => [
 617                                 'loadScript' => '//example.com/w/load.php',
 618                                 'apiScript' => '//example.com/w/api.php',
 619                         ],
 620                 ];
 621         }
 622
 623         /**
 624          * @covers ResourceLoader::getLoadScript
 625          */
 626         public function testGetLoadScript() {
 627                 $rl = new ResourceLoader();
 628                 $sources = self::fakeSources();
 629                 $rl->addSource( $sources );
 630                 foreach ( [ 'examplewiki', 'example2wiki' ] as $name ) {
 631                         $this->assertEquals( $rl->getLoadScript( $name ), $sources[$name]['loadScript'] );
 632                 }
 633
 634                 try {
 635                         $rl->getLoadScript( 'thiswasneverreigstered' );
 636                         $this->assertTrue( false, 'ResourceLoader::getLoadScript should have thrown an exception' );
 637                 } catch ( MWException $e ) {
 638                         $this->assertTrue( true );
 639                 }
 640         }
 641
 642         protected function getFailFerryMock( $getter = 'getScript' ) {
 643                 $mock = $this->getMockBuilder( ResourceLoaderTestModule::class )
 644                         ->setMethods( [ $getter ] )
 645                         ->getMock();
 646                 $mock->method( $getter )->will( $this->throwException(
 647                         new Exception( 'Ferry not found' )
 648                 ) );
 649                 return $mock;
 650         }
 651
 652         protected function getSimpleModuleMock( $script = '' ) {
 653                 $mock = $this->getMockBuilder( ResourceLoaderTestModule::class )
 654                         ->setMethods( [ 'getScript' ] )
 655                         ->getMock();
 656                 $mock->method( 'getScript' )->willReturn( $script );
 657                 return $mock;
 658         }
 659
 660         protected function getSimpleStyleModuleMock( $styles = '' ) {
 661                 $mock = $this->getMockBuilder( ResourceLoaderTestModule::class )
 662                         ->setMethods( [ 'getStyles' ] )
 663                         ->getMock();
 664                 $mock->method( 'getStyles' )->willReturn( [ '' => $styles ] );
 665                 return $mock;
 666         }
 667
 668         /**
 669          * @covers ResourceLoader::getCombinedVersion
 670          */
 671         public function testGetCombinedVersion() {
 672                 $rl = $this->getMockBuilder( EmptyResourceLoader::class )
 673                         // Disable log from outputErrorAndLog
 674                         ->setMethods( [ 'outputErrorAndLog' ] )->getMock();
 675                 $rl->register( [
 676                         'foo' => self::getSimpleModuleMock(),
 677                         'ferry' => self::getFailFerryMock(),
 678                         'bar' => self::getSimpleModuleMock(),
 679                 ] );
 680                 $context = $this->getResourceLoaderContext( [], $rl );
 681
 682                 $this->assertEquals(
 683                         '',
 684                         $rl->getCombinedVersion( $context, [] ),
 685                         'empty list'
 686                 );
 687
 688                 $this->assertEquals(
 689                         ResourceLoader::makeHash( self::BLANK_VERSION ),
 690                         $rl->getCombinedVersion( $context, [ 'foo' ] ),
 691                         'compute foo'
 692                 );
 693
 694                 // Verify that getCombinedVersion() does not throw when ferry fails.
 695                 // Instead it gracefully continues to combine the remaining modules.
 696                 $this->assertEquals(
 697                         ResourceLoader::makeHash( self::BLANK_VERSION . self::BLANK_VERSION ),
 698                         $rl->getCombinedVersion( $context, [ 'foo', 'ferry', 'bar' ] ),
 699                         'compute foo+ferry+bar (T152266)'
 700                 );
 701         }
 702
 703         public static function provideMakeModuleResponseConcat() {
 704                 $testcases = [
 705                         [
 706                                 'modules' => [
 707                                         'foo' => 'foo()',
 708                                 ],
 709                                 'expected' => "foo()\n" . 'mw.loader.state( {
 710     "foo": "ready"
 711 } );',
 712                                 'minified' => "foo()\n" . 'mw.loader.state({"foo":"ready"});',
 713                                 'message' => 'Script without semi-colon',
 714                         ],
 715                         [
 716                                 'modules' => [
 717                                         'foo' => 'foo()',
 718                                         'bar' => 'bar()',
 719                                 ],
 720                                 'expected' => "foo()\nbar()\n" . 'mw.loader.state( {
 721     "foo": "ready",
 722     "bar": "ready"
 723 } );',
 724                                 'minified' => "foo()\nbar()\n" . 'mw.loader.state({"foo":"ready","bar":"ready"});',
 725                                 'message' => 'Two scripts without semi-colon',
 726                         ],
 727                         [
 728                                 'modules' => [
 729                                         'foo' => "foo()\n// bar();"
 730                                 ],
 731                                 'expected' => "foo()\n// bar();\n" . 'mw.loader.state( {
 732     "foo": "ready"
 733 } );',
 734                                 'minified' => "foo()\n" . 'mw.loader.state({"foo":"ready"});',
 735                                 'message' => 'Script with semi-colon in comment (T162719)',
 736                         ],
 737                 ];
 738                 $ret = [];
 739                 foreach ( $testcases as $i => $case ) {
 740                         $ret["#$i"] = [
 741                                 $case['modules'],
 742                                 $case['expected'],
 743                                 true, // debug
 744                                 $case['message'],
 745                         ];
 746                         $ret["#$i (minified)"] = [
 747                                 $case['modules'],
 748                                 $case['minified'],
 749                                 false, // debug
 750                                 $case['message'],
 751                         ];
 752                 }
 753                 return $ret;
 754         }
 755
 756         /**
 757          * Verify how multiple scripts and mw.loader.state() calls are concatenated.
 758          *
 759          * @dataProvider provideMakeModuleResponseConcat
 760          * @covers ResourceLoader::makeModuleResponse
 761          */
 762         public function testMakeModuleResponseConcat( $scripts, $expected, $debug, $message = null ) {
 763                 $rl = new EmptyResourceLoader();
 764                 $modules = array_map( function ( $script ) {
 765                         return self::getSimpleModuleMock( $script );
 766                 }, $scripts );
 767                 $rl->register( $modules );
 768
 769                 $context = $this->getResourceLoaderContext(
 770                         [
 771                                 'modules' => implode( '|', array_keys( $modules ) ),
 772                                 'only' => 'scripts',
 773                                 'debug' => $debug ? 'true' : 'false',
 774                         ],
 775                         $rl
 776                 );
 777
 778                 $response = $rl->makeModuleResponse( $context, $modules );
 779                 $this->assertSame( [], $rl->getErrors(), 'Errors' );
 780                 $this->assertEquals( $expected, $response, $message ?: 'Response' );
 781         }
 782
 783         /**
 784          * @covers ResourceLoader::makeModuleResponse
 785          */
 786         public function testMakeModuleResponseEmpty() {
 787                 $rl = new EmptyResourceLoader();
 788                 $context = $this->getResourceLoaderContext(
 789                         [ 'modules' => '', 'only' => 'scripts' ],
 790                         $rl
 791                 );
 792
 793                 $response = $rl->makeModuleResponse( $context, [] );
 794                 $this->assertSame( [], $rl->getErrors(), 'Errors' );
 795                 $this->assertRegExp( '/^\/\*.+no modules were requested.+\*\/$/ms', $response );
 796         }
 797
 798         /**
 799          * Verify that when building module content in a load.php response,
 800          * an exception from one module will not break script output from
 801          * other modules.
 802          *
 803          * @covers ResourceLoader::makeModuleResponse
 804          */
 805         public function testMakeModuleResponseError() {
 806                 $modules = [
 807                         'foo' => self::getSimpleModuleMock( 'foo();' ),
 808                         'ferry' => self::getFailFerryMock(),
 809                         'bar' => self::getSimpleModuleMock( 'bar();' ),
 810                 ];
 811                 $rl = new EmptyResourceLoader();
 812                 $rl->register( $modules );
 813                 $context = $this->getResourceLoaderContext(
 814                         [
 815                                 'modules' => 'foo|ferry|bar',
 816                                 'only' => 'scripts',
 817                         ],
 818                         $rl
 819                 );
 820
 821                 // Disable log from makeModuleResponse via outputErrorAndLog
 822                 $this->setLogger( 'exception', new Psr\Log\NullLogger() );
 823
 824                 $response = $rl->makeModuleResponse( $context, $modules );
 825                 $errors = $rl->getErrors();
 826
 827                 $this->assertCount( 1, $errors );
 828                 $this->assertRegExp( '/Ferry not found/', $errors[0] );
 829                 $this->assertEquals(
 830                         "foo();\nbar();\n" . 'mw.loader.state( {
 831     "ferry": "error",
 832     "foo": "ready",
 833     "bar": "ready"
 834 } );',
 835                         $response
 836                 );
 837         }
 838
 839         /**
 840          * Verify that exceptions in PHP for one module will not break others
 841          * (stylesheet response).
 842          *
 843          * @covers ResourceLoader::makeModuleResponse
 844          */
 845         public function testMakeModuleResponseErrorCSS() {
 846                 $modules = [
 847                         'foo' => self::getSimpleStyleModuleMock( '.foo{}' ),
 848                         'ferry' => self::getFailFerryMock( 'getStyles' ),
 849                         'bar' => self::getSimpleStyleModuleMock( '.bar{}' ),
 850                 ];
 851                 $rl = new EmptyResourceLoader();
 852                 $rl->register( $modules );
 853                 $context = $this->getResourceLoaderContext(
 854                         [
 855                                 'modules' => 'foo|ferry|bar',
 856                                 'only' => 'styles',
 857                                 'debug' => 'false',
 858                         ],
 859                         $rl
 860                 );
 861
 862                 // Disable log from makeModuleResponse via outputErrorAndLog
 863                 $this->setLogger( 'exception', new Psr\Log\NullLogger() );
 864
 865                 $response = $rl->makeModuleResponse( $context, $modules );
 866                 $errors = $rl->getErrors();
 867
 868                 $this->assertCount( 2, $errors );
 869                 $this->assertRegExp( '/Ferry not found/', $errors[0] );
 870                 $this->assertRegExp( '/Problem.+"ferry":\s*"error"/ms', $errors[1] );
 871                 $this->assertEquals(
 872                         '.foo{}.bar{}',
 873                         $response
 874                 );
 875         }
 876
 877         /**
 878          * Verify that when building the startup module response,
 879          * an exception from one module class will not break the entire
 880          * startup module response. See T152266.
 881          *
 882          * @covers ResourceLoader::makeModuleResponse
 883          */
 884         public function testMakeModuleResponseStartupError() {
 885                 $rl = new EmptyResourceLoader();
 886                 $rl->register( [
 887                         'foo' => self::getSimpleModuleMock( 'foo();' ),
 888                         'ferry' => self::getFailFerryMock(),
 889                         'bar' => self::getSimpleModuleMock( 'bar();' ),
 890                         'startup' => [ 'class' => ResourceLoaderStartUpModule::class ],
 891                 ] );
 892                 $context = $this->getResourceLoaderContext(
 893                         [
 894                                 'modules' => 'startup',
 895                                 'only' => 'scripts',
 896                         ],
 897                         $rl
 898                 );
 899
 900                 $this->assertEquals(
 901                         [ 'foo', 'ferry', 'bar', 'startup' ],
 902                         $rl->getModuleNames(),
 903                         'getModuleNames'
 904                 );
 905
 906                 // Disable log from makeModuleResponse via outputErrorAndLog
 907                 $this->setLogger( 'exception', new Psr\Log\NullLogger() );
 908
 909                 $modules = [ 'startup' => $rl->getModule( 'startup' ) ];
 910                 $response = $rl->makeModuleResponse( $context, $modules );
 911                 $errors = $rl->getErrors();
 912
 913                 $this->assertRegExp( '/Ferry not found/', $errors[0] );
 914                 $this->assertCount( 1, $errors );
 915                 $this->assertRegExp(
 916                         '/isCompatible.*window\.RLQ/s',
 917                         $response,
 918                         'startup response undisrupted (T152266)'
 919                 );
 920                 $this->assertRegExp(
 921                         '/register\([^)]+"ferry",\s*""/s',
 922                         $response,
 923                         'startup response registers broken module'
 924                 );
 925                 $this->assertRegExp(
 926                         '/state\([^)]+"ferry":\s*"error"/s',
 927                         $response,
 928                         'startup response sets state to error'
 929                 );
 930         }
 931
 932         /**
 933          * Integration test for modules sending extra HTTP response headers.
 934          *
 935          * @covers ResourceLoaderModule::getHeaders
 936          * @covers ResourceLoaderModule::buildContent
 937          * @covers ResourceLoader::makeModuleResponse
 938          */
 939         public function testMakeModuleResponseExtraHeaders() {
 940                 $module = $this->getMockBuilder( ResourceLoaderTestModule::class )
 941                         ->setMethods( [ 'getPreloadLinks' ] )->getMock();
 942                 $module->method( 'getPreloadLinks' )->willReturn( [
 943                          'https://example.org/script.js' => [ 'as' => 'script' ],
 944                 ] );
 945
 946                 $rl = new EmptyResourceLoader();
 947                 $rl->register( [
 948                         'foo' => $module,
 949                 ] );
 950                 $context = $this->getResourceLoaderContext(
 951                         [ 'modules' => 'foo', 'only' => 'scripts' ],
 952                         $rl
 953                 );
 954
 955                 $modules = [ 'foo' => $rl->getModule( 'foo' ) ];
 956                 $response = $rl->makeModuleResponse( $context, $modules );
 957                 $extraHeaders = TestingAccessWrapper::newFromObject( $rl )->extraHeaders;
 958
 959                 $this->assertEquals(
 960                         [
 961                                 'Link: <https://example.org/script.js>;rel=preload;as=script'
 962                         ],
 963                         $extraHeaders,
 964                         'Extra headers'
 965                 );
 966         }
 967
 968         /**
 969          * @covers ResourceLoaderModule::getHeaders
 970          * @covers ResourceLoaderModule::buildContent
 971          * @covers ResourceLoader::makeModuleResponse
 972          */
 973         public function testMakeModuleResponseExtraHeadersMulti() {
 974                 $foo = $this->getMockBuilder( ResourceLoaderTestModule::class )
 975                         ->setMethods( [ 'getPreloadLinks' ] )->getMock();
 976                 $foo->method( 'getPreloadLinks' )->willReturn( [
 977                          'https://example.org/script.js' => [ 'as' => 'script' ],
 978                 ] );
 979
 980                 $bar = $this->getMockBuilder( ResourceLoaderTestModule::class )
 981                         ->setMethods( [ 'getPreloadLinks' ] )->getMock();
 982                 $bar->method( 'getPreloadLinks' )->willReturn( [
 983                          '/example.png' => [ 'as' => 'image' ],
 984                          '/example.jpg' => [ 'as' => 'image' ],
 985                 ] );
 986
 987                 $rl = new EmptyResourceLoader();
 988                 $rl->register( [ 'foo' => $foo, 'bar' => $bar ] );
 989                 $context = $this->getResourceLoaderContext(
 990                         [ 'modules' => 'foo|bar', 'only' => 'scripts' ],
 991                         $rl
 992                 );
 993
 994                 $modules = [ 'foo' => $rl->getModule( 'foo' ), 'bar' => $rl->getModule( 'bar' ) ];
 995                 $response = $rl->makeModuleResponse( $context, $modules );
 996                 $extraHeaders = TestingAccessWrapper::newFromObject( $rl )->extraHeaders;
 997                 $this->assertEquals(
 998                         [
 999                                 'Link: <https://example.org/script.js>;rel=preload;as=script',
1000                                 'Link: </example.png>;rel=preload;as=image,</example.jpg>;rel=preload;as=image'
1001                         ],
1002                         $extraHeaders,
1003                         'Extra headers'
1004                 );
1005         }
1006
1007         /**
1008          * @covers ResourceLoader::respond
1009          */
1010         public function testRespondEmpty() {
1011                 $rl = $this->getMockBuilder( EmptyResourceLoader::class )
1012                         ->setMethods( [
1013                                 'tryRespondNotModified',
1014                                 'sendResponseHeaders',
1015                                 'measureResponseTime',
1016                         ] )
1017                         ->getMock();
1018                 $context = $this->getResourceLoaderContext( [ 'modules' => '' ], $rl );
1019
1020                 $rl->expects( $this->once() )->method( 'measureResponseTime' );
1021                 $this->expectOutputRegex( '/no modules were requested/' );
1022
1023                 $rl->respond( $context );
1024         }
1025
1026         /**
1027          * @covers ResourceLoader::respond
1028          */
1029         public function testRespondSimple() {
1030                 $module = new ResourceLoaderTestModule( [ 'script' => 'foo();' ] );
1031                 $rl = $this->getMockBuilder( EmptyResourceLoader::class )
1032                         ->setMethods( [
1033                                 'measureResponseTime',
1034                                 'tryRespondNotModified',
1035                                 'sendResponseHeaders',
1036                                 'makeModuleResponse',
1037                         ] )
1038                         ->getMock();
1039                 $rl->register( 'test', $module );
1040                 $context = $this->getResourceLoaderContext(
1041                         [ 'modules' => 'test', 'only' => null ],
1042                         $rl
1043                 );
1044
1045                 $rl->expects( $this->once() )->method( 'makeModuleResponse' )
1046                         ->with( $context, [ 'test' => $module ] )
1047                         ->willReturn( 'implement_foo;' );
1048                 $this->expectOutputRegex( '/^implement_foo;/' );
1049
1050                 $rl->respond( $context );
1051         }
1052
1053         /**
1054          * @covers ResourceLoader::respond
1055          */
1056         public function testRespondInternalFailures() {
1057                 $module = new ResourceLoaderTestModule( [ 'script' => 'foo();' ] );
1058                 $rl = $this->getMockBuilder( EmptyResourceLoader::class )
1059                         ->setMethods( [
1060                                 'measureResponseTime',
1061                                 'preloadModuleInfo',
1062                                 'getCombinedVersion',
1063                                 'tryRespondNotModified',
1064                                 'makeModuleResponse',
1065                                 'sendResponseHeaders',
1066                         ] )
1067                         ->getMock();
1068                 $rl->register( 'test', $module );
1069                 $context = $this->getResourceLoaderContext( [ 'modules' => 'test' ], $rl );
1070                 // Disable logging from outputErrorAndLog
1071                 $this->setLogger( 'exception', new Psr\Log\NullLogger() );
1072
1073                 $rl->expects( $this->once() )->method( 'preloadModuleInfo' )
1074                         ->willThrowException( new Exception( 'Preload error' ) );
1075                 $rl->expects( $this->once() )->method( 'getCombinedVersion' )
1076                         ->willThrowException( new Exception( 'Version error' ) );
1077                 $rl->expects( $this->once() )->method( 'makeModuleResponse' )
1078                         ->with( $context, [ 'test' => $module ] )
1079                         ->willReturn( 'foo;' );
1080                 // Internal errors should be caught and logged without affecting module output
1081                 $this->expectOutputRegex( '/^\/\*.+Preload error.+Version error.+\*\/.*foo;/ms' );
1082
1083                 $rl->respond( $context );
1084         }
1085
1086         /**
1087          * @covers ResourceLoader::measureResponseTime
1088          */
1089         public function testMeasureResponseTime() {
1090                 $stats = $this->getMockBuilder( NullStatsdDataFactory::class )
1091                         ->setMethods( [ 'timing' ] )->getMock();
1092                 $this->setService( 'StatsdDataFactory', $stats );
1093
1094                 $stats->expects( $this->once() )->method( 'timing' )
1095                         ->with( 'resourceloader.responseTime', $this->anything() );
1096
1097                 $timing = new Timing();
1098                 $timing->mark( 'requestShutdown' );
1099                 $rl = TestingAccessWrapper::newFromObject( new EmptyResourceLoader );
1100                 $rl->measureResponseTime( $timing );
1101                 DeferredUpdates::doUpdates();
1102         }
1103 }