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( "local", "/w/load.php" );',
 517                         ResourceLoader::makeLoaderSourcesScript( 'local', '/w/load.php' )
 518                 );
 519                 $this->assertEquals(
 520                         'mw.loader.addSource( {
 521     "local": "/w/load.php"
 522 } );',
 523                         ResourceLoader::makeLoaderSourcesScript( [ 'local' => '/w/load.php' ] )
 524                 );
 525                 $this->assertEquals(
 526                         'mw.loader.addSource( {
 527     "local": "/w/load.php",
 528     "example": "https://example.org/w/load.php"
 529 } );',
 530                         ResourceLoader::makeLoaderSourcesScript( [
 531                                 'local' => '/w/load.php',
 532                                 'example' => 'https://example.org/w/load.php'
 533                         ] )
 534                 );
 535                 $this->assertEquals(
 536                         'mw.loader.addSource( [] );',
 537                         ResourceLoader::makeLoaderSourcesScript( [] )
 538                 );
 539         }
 540
 541         private static function fakeSources() {
 542                 return [
 543                         'examplewiki' => [
 544                                 'loadScript' => '//example.org/w/load.php',
 545                                 'apiScript' => '//example.org/w/api.php',
 546                         ],
 547                         'example2wiki' => [
 548                                 'loadScript' => '//example.com/w/load.php',
 549                                 'apiScript' => '//example.com/w/api.php',
 550                         ],
 551                 ];
 552         }
 553
 554         /**
 555          * @covers ResourceLoader::getLoadScript
 556          */
 557         public function testGetLoadScript() {
 558                 $this->setMwGlobals( 'wgResourceLoaderSources', [] );
 559                 $rl = new ResourceLoader();
 560                 $sources = self::fakeSources();
 561                 $rl->addSource( $sources );
 562                 foreach ( [ 'examplewiki', 'example2wiki' ] as $name ) {
 563                         $this->assertEquals( $rl->getLoadScript( $name ), $sources[$name]['loadScript'] );
 564                 }
 565
 566                 try {
 567                         $rl->getLoadScript( 'thiswasneverreigstered' );
 568                         $this->assertTrue( false, 'ResourceLoader::getLoadScript should have thrown an exception' );
 569                 } catch ( MWException $e ) {
 570                         $this->assertTrue( true );
 571                 }
 572         }
 573
 574         protected function getFailFerryMock( $getter = 'getScript' ) {
 575                 $mock = $this->getMockBuilder( ResourceLoaderTestModule::class )
 576                         ->setMethods( [ $getter ] )
 577                         ->getMock();
 578                 $mock->method( $getter )->will( $this->throwException(
 579                         new Exception( 'Ferry not found' )
 580                 ) );
 581                 return $mock;
 582         }
 583
 584         protected function getSimpleModuleMock( $script = '' ) {
 585                 $mock = $this->getMockBuilder( ResourceLoaderTestModule::class )
 586                         ->setMethods( [ 'getScript' ] )
 587                         ->getMock();
 588                 $mock->method( 'getScript' )->willReturn( $script );
 589                 return $mock;
 590         }
 591
 592         protected function getSimpleStyleModuleMock( $styles = '' ) {
 593                 $mock = $this->getMockBuilder( ResourceLoaderTestModule::class )
 594                         ->setMethods( [ 'getStyles' ] )
 595                         ->getMock();
 596                 $mock->method( 'getStyles' )->willReturn( [ '' => $styles ] );
 597                 return $mock;
 598         }
 599
 600         /**
 601          * @covers ResourceLoader::getCombinedVersion
 602          */
 603         public function testGetCombinedVersion() {
 604                 $rl = $this->getMockBuilder( EmptyResourceLoader::class )
 605                         // Disable log from outputErrorAndLog
 606                         ->setMethods( [ 'outputErrorAndLog' ] )->getMock();
 607                 $rl->register( [
 608                         'foo' => self::getSimpleModuleMock(),
 609                         'ferry' => self::getFailFerryMock(),
 610                         'bar' => self::getSimpleModuleMock(),
 611                 ] );
 612                 $context = $this->getResourceLoaderContext( [], $rl );
 613
 614                 $this->assertEquals(
 615                         '',
 616                         $rl->getCombinedVersion( $context, [] ),
 617                         'empty list'
 618                 );
 619
 620                 $this->assertEquals(
 621                         ResourceLoader::makeHash( self::BLANK_VERSION ),
 622                         $rl->getCombinedVersion( $context, [ 'foo' ] ),
 623                         'compute foo'
 624                 );
 625
 626                 // Verify that getCombinedVersion() does not throw when ferry fails.
 627                 // Instead it gracefully continues to combine the remaining modules.
 628                 $this->assertEquals(
 629                         ResourceLoader::makeHash( self::BLANK_VERSION . self::BLANK_VERSION ),
 630                         $rl->getCombinedVersion( $context, [ 'foo', 'ferry', 'bar' ] ),
 631                         'compute foo+ferry+bar (T152266)'
 632                 );
 633         }
 634
 635         public static function provideMakeModuleResponseConcat() {
 636                 $testcases = [
 637                         [
 638                                 'modules' => [
 639                                         'foo' => 'foo()',
 640                                 ],
 641                                 'expected' => "foo()\n" . 'mw.loader.state( {
 642     "foo": "ready"
 643 } );',
 644                                 'minified' => "foo()\n" . 'mw.loader.state({"foo":"ready"});',
 645                                 'message' => 'Script without semi-colon',
 646                         ],
 647                         [
 648                                 'modules' => [
 649                                         'foo' => 'foo()',
 650                                         'bar' => 'bar()',
 651                                 ],
 652                                 'expected' => "foo()\nbar()\n" . 'mw.loader.state( {
 653     "foo": "ready",
 654     "bar": "ready"
 655 } );',
 656                                 'minified' => "foo()\nbar()\n" . 'mw.loader.state({"foo":"ready","bar":"ready"});',
 657                                 'message' => 'Two scripts without semi-colon',
 658                         ],
 659                         [
 660                                 'modules' => [
 661                                         'foo' => "foo()\n// bar();"
 662                                 ],
 663                                 'expected' => "foo()\n// bar();\n" . 'mw.loader.state( {
 664     "foo": "ready"
 665 } );',
 666                                 'minified' => "foo()\n" . 'mw.loader.state({"foo":"ready"});',
 667                                 'message' => 'Script with semi-colon in comment (T162719)',
 668                         ],
 669                 ];
 670                 $ret = [];
 671                 foreach ( $testcases as $i => $case ) {
 672                         $ret["#$i"] = [
 673                                 $case['modules'],
 674                                 $case['expected'],
 675                                 true, // debug
 676                                 $case['message'],
 677                         ];
 678                         $ret["#$i (minified)"] = [
 679                                 $case['modules'],
 680                                 $case['minified'],
 681                                 false, // debug
 682                                 $case['message'],
 683                         ];
 684                 }
 685                 return $ret;
 686         }
 687
 688         /**
 689          * Verify how multiple scripts and mw.loader.state() calls are concatenated.
 690          *
 691          * @dataProvider provideMakeModuleResponseConcat
 692          * @covers ResourceLoader::makeModuleResponse
 693          */
 694         public function testMakeModuleResponseConcat( $scripts, $expected, $debug, $message = null ) {
 695                 $rl = new EmptyResourceLoader();
 696                 $modules = array_map( function ( $script ) {
 697                         return self::getSimpleModuleMock( $script );
 698                 }, $scripts );
 699                 $rl->register( $modules );
 700
 701                 $this->setMwGlobals( 'wgResourceLoaderDebug', $debug );
 702                 $context = $this->getResourceLoaderContext(
 703                         [
 704                                 'modules' => implode( '|', array_keys( $modules ) ),
 705                                 'only' => 'scripts',
 706                         ],
 707                         $rl
 708                 );
 709
 710                 $response = $rl->makeModuleResponse( $context, $modules );
 711                 $this->assertSame( [], $rl->getErrors(), 'Errors' );
 712                 $this->assertEquals( $expected, $response, $message ?: 'Response' );
 713         }
 714
 715         /**
 716          * @covers ResourceLoader::makeModuleResponse
 717          */
 718         public function testMakeModuleResponseEmpty() {
 719                 $rl = new EmptyResourceLoader();
 720                 $context = $this->getResourceLoaderContext(
 721                         [ 'modules' => '', 'only' => 'scripts' ],
 722                         $rl
 723                 );
 724
 725                 $response = $rl->makeModuleResponse( $context, [] );
 726                 $this->assertSame( [], $rl->getErrors(), 'Errors' );
 727                 $this->assertRegExp( '/^\/\*.+no modules were requested.+\*\/$/ms', $response );
 728         }
 729
 730         /**
 731          * Verify that when building module content in a load.php response,
 732          * an exception from one module will not break script output from
 733          * other modules.
 734          *
 735          * @covers ResourceLoader::makeModuleResponse
 736          */
 737         public function testMakeModuleResponseError() {
 738                 $modules = [
 739                         'foo' => self::getSimpleModuleMock( 'foo();' ),
 740                         'ferry' => self::getFailFerryMock(),
 741                         'bar' => self::getSimpleModuleMock( 'bar();' ),
 742                 ];
 743                 $rl = new EmptyResourceLoader();
 744                 $rl->register( $modules );
 745                 $context = $this->getResourceLoaderContext(
 746                         [
 747                                 'modules' => 'foo|ferry|bar',
 748                                 'only' => 'scripts',
 749                         ],
 750                         $rl
 751                 );
 752
 753                 // Disable log from makeModuleResponse via outputErrorAndLog
 754                 $this->setLogger( 'exception', new Psr\Log\NullLogger() );
 755
 756                 $response = $rl->makeModuleResponse( $context, $modules );
 757                 $errors = $rl->getErrors();
 758
 759                 $this->assertCount( 1, $errors );
 760                 $this->assertRegExp( '/Ferry not found/', $errors[0] );
 761                 $this->assertEquals(
 762                         "foo();\nbar();\n" . 'mw.loader.state( {
 763     "ferry": "error",
 764     "foo": "ready",
 765     "bar": "ready"
 766 } );',
 767                         $response
 768                 );
 769         }
 770
 771         /**
 772          * Verify that exceptions in PHP for one module will not break others
 773          * (stylesheet response).
 774          *
 775          * @covers ResourceLoader::makeModuleResponse
 776          */
 777         public function testMakeModuleResponseErrorCSS() {
 778                 $modules = [
 779                         'foo' => self::getSimpleStyleModuleMock( '.foo{}' ),
 780                         'ferry' => self::getFailFerryMock( 'getStyles' ),
 781                         'bar' => self::getSimpleStyleModuleMock( '.bar{}' ),
 782                 ];
 783                 $rl = new EmptyResourceLoader();
 784                 $rl->register( $modules );
 785                 $context = $this->getResourceLoaderContext(
 786                         [
 787                                 'modules' => 'foo|ferry|bar',
 788                                 'only' => 'styles',
 789                                 'debug' => 'false',
 790                         ],
 791                         $rl
 792                 );
 793
 794                 // Disable log from makeModuleResponse via outputErrorAndLog
 795                 $this->setLogger( 'exception', new Psr\Log\NullLogger() );
 796
 797                 $response = $rl->makeModuleResponse( $context, $modules );
 798                 $errors = $rl->getErrors();
 799
 800                 $this->assertCount( 2, $errors );
 801                 $this->assertRegExp( '/Ferry not found/', $errors[0] );
 802                 $this->assertRegExp( '/Problem.+"ferry":\s*"error"/ms', $errors[1] );
 803                 $this->assertEquals(
 804                         '.foo{}.bar{}',
 805                         $response
 806                 );
 807         }
 808         /**
 809          * Verify that when building the startup module response,
 810          * an exception from one module class will not break the entire
 811          * startup module response. See T152266.
 812          *
 813          * @covers ResourceLoader::makeModuleResponse
 814          */
 815         public function testMakeModuleResponseStartupError() {
 816                 $rl = new EmptyResourceLoader();
 817                 $rl->register( [
 818                         'foo' => self::getSimpleModuleMock( 'foo();' ),
 819                         'ferry' => self::getFailFerryMock(),
 820                         'bar' => self::getSimpleModuleMock( 'bar();' ),
 821                         'startup' => [ 'class' => ResourceLoaderStartUpModule::class ],
 822                 ] );
 823                 $context = $this->getResourceLoaderContext(
 824                         [
 825                                 'modules' => 'startup',
 826                                 'only' => 'scripts',
 827                         ],
 828                         $rl
 829                 );
 830
 831                 $this->assertEquals(
 832                         [ 'foo', 'ferry', 'bar', 'startup' ],
 833                         $rl->getModuleNames(),
 834                         'getModuleNames'
 835                 );
 836
 837                 // Disable log from makeModuleResponse via outputErrorAndLog
 838                 $this->setLogger( 'exception', new Psr\Log\NullLogger() );
 839
 840                 $modules = [ 'startup' => $rl->getModule( 'startup' ) ];
 841                 $response = $rl->makeModuleResponse( $context, $modules );
 842                 $errors = $rl->getErrors();
 843
 844                 $this->assertRegExp( '/Ferry not found/', $errors[0] );
 845                 $this->assertCount( 1, $errors );
 846                 $this->assertRegExp(
 847                         '/isCompatible.*function startUp/s',
 848                         $response,
 849                         'startup response undisrupted (T152266)'
 850                 );
 851                 $this->assertRegExp(
 852                         '/register\([^)]+"ferry",\s*""/s',
 853                         $response,
 854                         'startup response registers broken module'
 855                 );
 856                 $this->assertRegExp(
 857                         '/state\([^)]+"ferry":\s*"error"/s',
 858                         $response,
 859                         'startup response sets state to error'
 860                 );
 861         }
 862
 863         /**
 864          * Integration test for modules sending extra HTTP response headers.
 865          *
 866          * @covers ResourceLoaderModule::getHeaders
 867          * @covers ResourceLoaderModule::buildContent
 868          * @covers ResourceLoader::makeModuleResponse
 869          */
 870         public function testMakeModuleResponseExtraHeaders() {
 871                 $module = $this->getMockBuilder( ResourceLoaderTestModule::class )
 872                         ->setMethods( [ 'getPreloadLinks' ] )->getMock();
 873                 $module->method( 'getPreloadLinks' )->willReturn( [
 874                          'https://example.org/script.js' => [ 'as' => 'script' ],
 875                 ] );
 876
 877                 $rl = new EmptyResourceLoader();
 878                 $rl->register( [
 879                         'foo' => $module,
 880                 ] );
 881                 $context = $this->getResourceLoaderContext(
 882                         [ 'modules' => 'foo', 'only' => 'scripts' ],
 883                         $rl
 884                 );
 885
 886                 $modules = [ 'foo' => $rl->getModule( 'foo' ) ];
 887                 $response = $rl->makeModuleResponse( $context, $modules );
 888                 $extraHeaders = TestingAccessWrapper::newFromObject( $rl )->extraHeaders;
 889
 890                 $this->assertEquals(
 891                         [
 892                                 'Link: <https://example.org/script.js>;rel=preload;as=script'
 893                         ],
 894                         $extraHeaders,
 895                         'Extra headers'
 896                 );
 897         }
 898
 899         /**
 900          * @covers ResourceLoaderModule::getHeaders
 901          * @covers ResourceLoaderModule::buildContent
 902          * @covers ResourceLoader::makeModuleResponse
 903          */
 904         public function testMakeModuleResponseExtraHeadersMulti() {
 905                 $foo = $this->getMockBuilder( ResourceLoaderTestModule::class )
 906                         ->setMethods( [ 'getPreloadLinks' ] )->getMock();
 907                 $foo->method( 'getPreloadLinks' )->willReturn( [
 908                          'https://example.org/script.js' => [ 'as' => 'script' ],
 909                 ] );
 910
 911                 $bar = $this->getMockBuilder( ResourceLoaderTestModule::class )
 912                         ->setMethods( [ 'getPreloadLinks' ] )->getMock();
 913                 $bar->method( 'getPreloadLinks' )->willReturn( [
 914                          '/example.png' => [ 'as' => 'image' ],
 915                          '/example.jpg' => [ 'as' => 'image' ],
 916                 ] );
 917
 918                 $rl = new EmptyResourceLoader();
 919                 $rl->register( [ 'foo' => $foo, 'bar' => $bar ] );
 920                 $context = $this->getResourceLoaderContext(
 921                         [ 'modules' => 'foo|bar', 'only' => 'scripts' ],
 922                         $rl
 923                 );
 924
 925                 $modules = [ 'foo' => $rl->getModule( 'foo' ), 'bar' => $rl->getModule( 'bar' ) ];
 926                 $response = $rl->makeModuleResponse( $context, $modules );
 927                 $extraHeaders = TestingAccessWrapper::newFromObject( $rl )->extraHeaders;
 928                 $this->assertEquals(
 929                         [
 930                                 'Link: <https://example.org/script.js>;rel=preload;as=script',
 931                                 'Link: </example.png>;rel=preload;as=image,</example.jpg>;rel=preload;as=image'
 932                         ],
 933                         $extraHeaders,
 934                         'Extra headers'
 935                 );
 936         }
 937
 938         /**
 939          * @covers ResourceLoader::respond
 940          */
 941         public function testRespondEmpty() {
 942                 $rl = $this->getMockBuilder( EmptyResourceLoader::class )
 943                         ->setMethods( [
 944                                 'tryRespondNotModified',
 945                                 'sendResponseHeaders',
 946                                 'measureResponseTime',
 947                         ] )
 948                         ->getMock();
 949                 $context = $this->getResourceLoaderContext( [ 'modules' => '' ], $rl );
 950
 951                 $rl->expects( $this->once() )->method( 'measureResponseTime' );
 952                 $this->expectOutputRegex( '/no modules were requested/' );
 953
 954                 $rl->respond( $context );
 955         }
 956
 957         /**
 958          * @covers ResourceLoader::respond
 959          */
 960         public function testRespondSimple() {
 961                 $module = new ResourceLoaderTestModule( [ 'script' => 'foo();' ] );
 962                 $rl = $this->getMockBuilder( EmptyResourceLoader::class )
 963                         ->setMethods( [
 964                                 'measureResponseTime',
 965                                 'tryRespondNotModified',
 966                                 'sendResponseHeaders',
 967                                 'makeModuleResponse',
 968                         ] )
 969                         ->getMock();
 970                 $rl->register( 'test', $module );
 971                 $context = $this->getResourceLoaderContext(
 972                         [ 'modules' => 'test', 'only' => null ],
 973                         $rl
 974                 );
 975
 976                 $rl->expects( $this->once() )->method( 'makeModuleResponse' )
 977                         ->with( $context, [ 'test' => $module ] )
 978                         ->willReturn( 'implement_foo;' );
 979                 $this->expectOutputRegex( '/^implement_foo;/' );
 980
 981                 $rl->respond( $context );
 982         }
 983
 984         /**
 985          * @covers ResourceLoader::respond
 986          */
 987         public function testRespondInternalFailures() {
 988                 $module = new ResourceLoaderTestModule( [ 'script' => 'foo();' ] );
 989                 $rl = $this->getMockBuilder( EmptyResourceLoader::class )
 990                         ->setMethods( [
 991                                 'measureResponseTime',
 992                                 'preloadModuleInfo',
 993                                 'getCombinedVersion',
 994                                 'tryRespondNotModified',
 995                                 'makeModuleResponse',
 996                                 'sendResponseHeaders',
 997                         ] )
 998                         ->getMock();
 999                 $rl->register( 'test', $module );
1000                 $context = $this->getResourceLoaderContext( [ 'modules' => 'test' ], $rl );
1001                 // Disable logging from outputErrorAndLog
1002                 $this->setLogger( 'exception', new Psr\Log\NullLogger() );
1003
1004                 $rl->expects( $this->once() )->method( 'preloadModuleInfo' )
1005                         ->willThrowException( new Exception( 'Preload error' ) );
1006                 $rl->expects( $this->once() )->method( 'getCombinedVersion' )
1007                         ->willThrowException( new Exception( 'Version error' ) );
1008                 $rl->expects( $this->once() )->method( 'makeModuleResponse' )
1009                         ->with( $context, [ 'test' => $module ] )
1010                         ->willReturn( 'foo;' );
1011                 // Internal errors should be caught and logged without affecting module output
1012                 $this->expectOutputRegex( '/^\/\*.+Preload error.+Version error.+\*\/.*foo;/ms' );
1013
1014                 $rl->respond( $context );
1015         }
1016
1017         /**
1018          * @covers ResourceLoader::measureResponseTime
1019          */
1020         public function testMeasureResponseTime() {
1021                 $stats = $this->getMockBuilder( NullStatsdDataFactory::class )
1022                         ->setMethods( [ 'timing' ] )->getMock();
1023                 $this->setService( 'StatsdDataFactory', $stats );
1024
1025                 $stats->expects( $this->once() )->method( 'timing' )
1026                         ->with( 'resourceloader.responseTime', $this->anything() );
1027
1028                 $timing = new Timing();
1029                 $timing->mark( 'requestShutdown' );
1030                 $rl = TestingAccessWrapper::newFromObject( new EmptyResourceLoader );
1031                 $rl->measureResponseTime( $timing );
1032                 DeferredUpdates::doUpdates();
1033         }
1034 }