tests/phpunit/includes/resourceloader/ResourceLoaderTest.php

   1 <?php
   2
   3 class ResourceLoaderTest extends ResourceLoaderTestCase {
   4
   5         protected function setUp() {
   6                 parent::setUp();
   7
   8                 $this->setMwGlobals( [
   9                         'wgResourceLoaderLESSImportPaths' => [
  10                                 dirname( dirname( __DIR__ ) ) . '/data/less/common',
  11                         ],
  12                         'wgResourceLoaderLESSVars' => [
  13                                 'foo'  => '2px',
  14                                 'Foo' => '#eeeeee',
  15                                 'bar' => 5,
  16                         ],
  17                 ] );
  18         }
  19
  20         /**
  21          * Ensure the ResourceLoaderRegisterModules hook is called.
  22          *
  23          * @covers ResourceLoader::__construct
  24          */
  25         public function testConstructRegistrationHook() {
  26                 $resourceLoaderRegisterModulesHook = false;
  27
  28                 $this->setMwGlobals( 'wgHooks', [
  29                         'ResourceLoaderRegisterModules' => [
  30                                 function ( &$resourceLoader ) use ( &$resourceLoaderRegisterModulesHook ) {
  31                                         $resourceLoaderRegisterModulesHook = true;
  32                                 }
  33                         ]
  34                 ] );
  35
  36                 $unused = new ResourceLoader();
  37                 $this->assertTrue(
  38                         $resourceLoaderRegisterModulesHook,
  39                         'Hook ResourceLoaderRegisterModules called'
  40                 );
  41         }
  42
  43         /**
  44          * @covers ResourceLoader::register
  45          * @covers ResourceLoader::getModule
  46          */
  47         public function testRegisterValid() {
  48                 $module = new ResourceLoaderTestModule();
  49                 $resourceLoader = new EmptyResourceLoader();
  50                 $resourceLoader->register( 'test', $module );
  51                 $this->assertEquals( $module, $resourceLoader->getModule( 'test' ) );
  52         }
  53
  54         /**
  55          * @covers ResourceLoader::register
  56          */
  57         public function testRegisterInvalidName() {
  58                 $resourceLoader = new EmptyResourceLoader();
  59                 $this->setExpectedException( 'MWException', "name 'test!invalid' is invalid" );
  60                 $resourceLoader->register( 'test!invalid', new ResourceLoaderTestModule() );
  61         }
  62
  63         /**
  64          * @covers ResourceLoader::register
  65          */
  66         public function testRegisterInvalidType() {
  67                 $resourceLoader = new EmptyResourceLoader();
  68                 $this->setExpectedException( 'MWException', 'ResourceLoader module info type error' );
  69                 $resourceLoader->register( 'test', new stdClass() );
  70         }
  71
  72         /**
  73          * @covers ResourceLoader::getModuleNames
  74          */
  75         public function testGetModuleNames() {
  76                 // Use an empty one so that core and extension modules don't get in.
  77                 $resourceLoader = new EmptyResourceLoader();
  78                 $resourceLoader->register( 'test.foo', new ResourceLoaderTestModule() );
  79                 $resourceLoader->register( 'test.bar', new ResourceLoaderTestModule() );
  80                 $this->assertEquals(
  81                         [ 'test.foo', 'test.bar' ],
  82                         $resourceLoader->getModuleNames()
  83                 );
  84         }
  85
  86         /**
  87          * @covers ResourceLoader::isModuleRegistered
  88          */
  89         public function testIsModuleRegistered() {
  90                 $rl = new EmptyResourceLoader();
  91                 $rl->register( 'test', new ResourceLoaderTestModule() );
  92                 $this->assertTrue( $rl->isModuleRegistered( 'test' ) );
  93                 $this->assertFalse( $rl->isModuleRegistered( 'test.unknown' ) );
  94         }
  95
  96         /**
  97          * @covers ResourceLoader::getModule
  98          */
  99         public function testGetModuleUnknown() {
 100                 $rl = new EmptyResourceLoader();
 101                 $this->assertSame( null, $rl->getModule( 'test' ) );
 102         }
 103
 104         /**
 105          * @covers ResourceLoader::getModule
 106          */
 107         public function testGetModuleClass() {
 108                 $rl = new EmptyResourceLoader();
 109                 $rl->register( 'test', [ 'class' => ResourceLoaderTestModule::class ] );
 110                 $this->assertInstanceOf(
 111                         ResourceLoaderTestModule::class,
 112                         $rl->getModule( 'test' )
 113                 );
 114         }
 115
 116         /**
 117          * @covers ResourceLoader::getModule
 118          */
 119         public function testGetModuleClassDefault() {
 120                 $rl = new EmptyResourceLoader();
 121                 $rl->register( 'test', [] );
 122                 $this->assertInstanceOf(
 123                         ResourceLoaderFileModule::class,
 124                         $rl->getModule( 'test' ),
 125                         'Array-style module registrations default to FileModule'
 126                 );
 127         }
 128
 129         /**
 130          * @covers ResourceLoaderFileModule::compileLessFile
 131          */
 132         public function testLessFileCompilation() {
 133                 $context = $this->getResourceLoaderContext();
 134                 $basePath = __DIR__ . '/../../data/less/module';
 135                 $module = new ResourceLoaderFileModule( [
 136                         'localBasePath' => $basePath,
 137                         'styles' => [ 'styles.less' ],
 138                 ] );
 139                 $module->setName( 'test.less' );
 140                 $styles = $module->getStyles( $context );
 141                 $this->assertStringEqualsFile( $basePath . '/styles.css', $styles['all'] );
 142         }
 143
 144         public static function providePackedModules() {
 145                 return [
 146                         [
 147                                 'Example from makePackedModulesString doc comment',
 148                                 [ 'foo.bar', 'foo.baz', 'bar.baz', 'bar.quux' ],
 149                                 'foo.bar,baz|bar.baz,quux',
 150                         ],
 151                         [
 152                                 'Example from expandModuleNames doc comment',
 153                                 [ 'jquery.foo', 'jquery.bar', 'jquery.ui.baz', 'jquery.ui.quux' ],
 154                                 'jquery.foo,bar|jquery.ui.baz,quux',
 155                         ],
 156                         [
 157                                 'Regression fixed in r88706 with dotless names',
 158                                 [ 'foo', 'bar', 'baz' ],
 159                                 'foo,bar,baz',
 160                         ],
 161                         [
 162                                 'Prefixless modules after a prefixed module',
 163                                 [ 'single.module', 'foobar', 'foobaz' ],
 164                                 'single.module|foobar,foobaz',
 165                         ],
 166                         [
 167                                 'Ordering',
 168                                 [ 'foo', 'foo.baz', 'baz.quux', 'foo.bar' ],
 169                                 'foo|foo.baz,bar|baz.quux',
 170                                 [ 'foo', 'foo.baz', 'foo.bar', 'baz.quux' ],
 171                         ]
 172                 ];
 173         }
 174
 175         /**
 176          * @dataProvider providePackedModules
 177          * @covers ResourceLoader::makePackedModulesString
 178          */
 179         public function testMakePackedModulesString( $desc, $modules, $packed ) {
 180                 $this->assertEquals( $packed, ResourceLoader::makePackedModulesString( $modules ), $desc );
 181         }
 182
 183         /**
 184          * @dataProvider providePackedModules
 185          * @covers ResourceLoaderContext::expandModuleNames
 186          */
 187         public function testExpandModuleNames( $desc, $modules, $packed, $unpacked = null ) {
 188                 $this->assertEquals(
 189                         $unpacked ?: $modules,
 190                         ResourceLoaderContext::expandModuleNames( $packed ),
 191                         $desc
 192                 );
 193         }
 194
 195         public static function provideAddSource() {
 196                 return [
 197                         [ 'foowiki', 'https://example.org/w/load.php', 'foowiki' ],
 198                         [ 'foowiki', [ 'loadScript' => 'https://example.org/w/load.php' ], 'foowiki' ],
 199                         [
 200                                 [
 201                                         'foowiki' => 'https://example.org/w/load.php',
 202                                         'bazwiki' => 'https://example.com/w/load.php',
 203                                 ],
 204                                 null,
 205                                 [ 'foowiki', 'bazwiki' ]
 206                         ]
 207                 ];
 208         }
 209
 210         /**
 211          * @dataProvider provideAddSource
 212          * @covers ResourceLoader::addSource
 213          * @covers ResourceLoader::getSources
 214          */
 215         public function testAddSource( $name, $info, $expected ) {
 216                 $rl = new ResourceLoader;
 217                 $rl->addSource( $name, $info );
 218                 if ( is_array( $expected ) ) {
 219                         foreach ( $expected as $source ) {
 220                                 $this->assertArrayHasKey( $source, $rl->getSources() );
 221                         }
 222                 } else {
 223                         $this->assertArrayHasKey( $expected, $rl->getSources() );
 224                 }
 225         }
 226
 227         /**
 228          * @covers ResourceLoader::addSource
 229          */
 230         public function testAddSourceDupe() {
 231                 $rl = new ResourceLoader;
 232                 $this->setExpectedException( 'MWException', 'ResourceLoader duplicate source addition error' );
 233                 $rl->addSource( 'foo', 'https://example.org/w/load.php' );
 234                 $rl->addSource( 'foo', 'https://example.com/w/load.php' );
 235         }
 236
 237         /**
 238          * @covers ResourceLoader::addSource
 239          */
 240         public function testAddSourceInvalid() {
 241                 $rl = new ResourceLoader;
 242                 $this->setExpectedException( 'MWException', 'with no "loadScript" key' );
 243                 $rl->addSource( 'foo',  [ 'x' => 'https://example.org/w/load.php' ] );
 244         }
 245
 246         public static function provideLoaderImplement() {
 247                 return [
 248                         [ [
 249                                 'title' => 'Implement scripts, styles and messages',
 250
 251                                 'name' => 'test.example',
 252                                 'scripts' => 'mw.example();',
 253                                 'styles' => [ 'css' => [ '.mw-example {}' ] ],
 254                                 'messages' => [ 'example' => '' ],
 255                                 'templates' => [],
 256
 257                                 'expected' => 'mw.loader.implement( "test.example", function ( $, jQuery, require, module ) {
 258 mw.example();
 259 }, {
 260     "css": [
 261         ".mw-example {}"
 262     ]
 263 }, {
 264     "example": ""
 265 } );',
 266                         ] ],
 267                         [ [
 268                                 'title' => 'Implement scripts',
 269
 270                                 'name' => 'test.example',
 271                                 'scripts' => 'mw.example();',
 272                                 'styles' => [],
 273
 274                                 'expected' => 'mw.loader.implement( "test.example", function ( $, jQuery, require, module ) {
 275 mw.example();
 276 } );',
 277                         ] ],
 278                         [ [
 279                                 'title' => 'Implement styles',
 280
 281                                 'name' => 'test.example',
 282                                 'scripts' => [],
 283                                 'styles' => [ 'css' => [ '.mw-example {}' ] ],
 284                                 'messages' => new XmlJsCode( '{}' ),
 285
 286                                 'expected' => 'mw.loader.implement( "test.example", [], {
 287     "css": [
 288         ".mw-example {}"
 289     ]
 290 } );',
 291                         ] ],
 292                         [ [
 293                                 'title' => 'Implement scripts and messages',
 294
 295                                 'name' => 'test.example',
 296                                 'scripts' => 'mw.example();',
 297                                 'messages' => [ 'example' => '' ],
 298
 299                                 'expected' => 'mw.loader.implement( "test.example", function ( $, jQuery, require, module ) {
 300 mw.example();
 301 }, {}, {
 302     "example": ""
 303 } );',
 304                         ] ],
 305                         [ [
 306                                 'title' => 'Implement scripts and templates',
 307
 308                                 'name' => 'test.example',
 309                                 'scripts' => 'mw.example();',
 310                                 'templates' => [ 'example.html' => '' ],
 311
 312                                 'expected' => 'mw.loader.implement( "test.example", function ( $, jQuery, require, module ) {
 313 mw.example();
 314 }, {}, {}, {
 315     "example.html": ""
 316 } );',
 317                         ] ],
 318                         [ [
 319                                 'title' => 'Implement unwrapped user script',
 320
 321                                 'name' => 'user',
 322                                 'scripts' => 'mw.example( 1 );',
 323
 324                                 'expected' => 'mw.loader.implement( "user", "mw.example( 1 );" );',
 325                         ] ],
 326                         [ [
 327                                 'title' => 'Implement unwrapped user script',
 328                                 'debug' => false,
 329
 330                                 'name' => 'user',
 331                                 'scripts' => 'mw.example( 1 );',
 332
 333                                 'expected' => 'mw.loader.implement("user","mw.example(1);");',
 334                         ] ],
 335                 ];
 336         }
 337
 338         /**
 339          * @dataProvider provideLoaderImplement
 340          * @covers ResourceLoader::makeLoaderImplementScript
 341          * @covers ResourceLoader::trimArray
 342          */
 343         public function testMakeLoaderImplementScript( $case ) {
 344                 $case += [
 345                         'styles' => [], 'templates' => [], 'messages' => new XmlJsCode( '{}' ),
 346                         'debug' => true
 347                 ];
 348                 ResourceLoader::clearCache();
 349                 $this->setMwGlobals( 'wgResourceLoaderDebug', $case['debug'] );
 350
 351                 $this->assertEquals(
 352                         $case['expected'],
 353                         ResourceLoader::makeLoaderImplementScript(
 354                                 $case['name'],
 355                                 $case['scripts'],
 356                                 $case['styles'],
 357                                 $case['messages'],
 358                                 $case['templates']
 359                         )
 360                 );
 361         }
 362
 363         /**
 364          * @covers ResourceLoader::makeLoaderImplementScript
 365          */
 366         public function testMakeLoaderImplementScriptInvalid() {
 367                 $this->setExpectedException( 'MWException', 'Invalid scripts error' );
 368                 ResourceLoader::makeLoaderImplementScript(
 369                         'test', // name
 370                         123, // scripts
 371                         null, // styles
 372                         null, // messages
 373                         null // templates
 374                 );
 375         }
 376
 377         /**
 378          * @covers ResourceLoader::makeLoaderSourcesScript
 379          */
 380         public function testMakeLoaderSourcesScript() {
 381                 $this->assertEquals(
 382                         'mw.loader.addSource( "local", "/w/load.php" );',
 383                         ResourceLoader::makeLoaderSourcesScript( 'local', '/w/load.php' )
 384                 );
 385                 $this->assertEquals(
 386                         'mw.loader.addSource( {
 387     "local": "/w/load.php"
 388 } );',
 389                         ResourceLoader::makeLoaderSourcesScript( [ 'local' => '/w/load.php' ] )
 390                 );
 391                 $this->assertEquals(
 392                         'mw.loader.addSource( {
 393     "local": "/w/load.php",
 394     "example": "https://example.org/w/load.php"
 395 } );',
 396                         ResourceLoader::makeLoaderSourcesScript( [
 397                                 'local' => '/w/load.php',
 398                                 'example' => 'https://example.org/w/load.php'
 399                         ] )
 400                 );
 401                 $this->assertEquals(
 402                         'mw.loader.addSource( [] );',
 403                         ResourceLoader::makeLoaderSourcesScript( [] )
 404                 );
 405         }
 406
 407         private static function fakeSources() {
 408                 return [
 409                         'examplewiki' => [
 410                                 'loadScript' => '//example.org/w/load.php',
 411                                 'apiScript' => '//example.org/w/api.php',
 412                         ],
 413                         'example2wiki' => [
 414                                 'loadScript' => '//example.com/w/load.php',
 415                                 'apiScript' => '//example.com/w/api.php',
 416                         ],
 417                 ];
 418         }
 419
 420         /**
 421          * @covers ResourceLoader::getLoadScript
 422          */
 423         public function testGetLoadScript() {
 424                 $this->setMwGlobals( 'wgResourceLoaderSources', [] );
 425                 $rl = new ResourceLoader();
 426                 $sources = self::fakeSources();
 427                 $rl->addSource( $sources );
 428                 foreach ( [ 'examplewiki', 'example2wiki' ] as $name ) {
 429                         $this->assertEquals( $rl->getLoadScript( $name ), $sources[$name]['loadScript'] );
 430                 }
 431
 432                 try {
 433                         $rl->getLoadScript( 'thiswasneverreigstered' );
 434                         $this->assertTrue( false, 'ResourceLoader::getLoadScript should have thrown an exception' );
 435                 } catch ( MWException $e ) {
 436                         $this->assertTrue( true );
 437                 }
 438         }
 439 }