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