tests/phpunit/includes/resourceloader/ResourceLoaderWikiModuleTest.php

   1 <?php
   2
   3 class ResourceLoaderWikiModuleTest extends ResourceLoaderTestCase {
   4
   5         /**
   6          * @covers ResourceLoaderWikiModule::__construct
   7          * @dataProvider provideConstructor
   8          */
   9         public function testConstructor( $params ) {
  10                 $module = new ResourceLoaderWikiModule( $params );
  11                 $this->assertInstanceOf( 'ResourceLoaderWikiModule', $module );
  12         }
  13
  14         public static function provideConstructor() {
  15                 return [
  16                         // Nothing
  17                         [ null ],
  18                         [ [] ],
  19                         // Unrecognized settings
  20                         [ [ 'foo' => 'baz' ] ],
  21                         // Real settings
  22                         [ [ 'scripts' => [ 'MediaWiki:Common.js' ] ] ],
  23                 ];
  24         }
  25
  26         /**
  27          * @dataProvider provideGetPages
  28          * @covers ResourceLoaderWikiModule::getPages
  29          */
  30         public function testGetPages( $params, Config $config, $expected ) {
  31                 $module = new ResourceLoaderWikiModule( $params );
  32                 $module->setConfig( $config );
  33
  34                 // Because getPages is protected..
  35                 $getPages = new ReflectionMethod( $module, 'getPages' );
  36                 $getPages->setAccessible( true );
  37                 $out = $getPages->invoke( $module, ResourceLoaderContext::newDummyContext() );
  38                 $this->assertEquals( $expected, $out );
  39         }
  40
  41         public static function provideGetPages() {
  42                 $settings = self::getSettings() + [
  43                         'UseSiteJs' => true,
  44                         'UseSiteCss' => true,
  45                 ];
  46
  47                 $params = [
  48                         'styles' => [ 'MediaWiki:Common.css' ],
  49                         'scripts' => [ 'MediaWiki:Common.js' ],
  50                 ];
  51
  52                 return [
  53                         [ [], new HashConfig( $settings ), [] ],
  54                         [ $params, new HashConfig( $settings ), [
  55                                 'MediaWiki:Common.js' => [ 'type' => 'script' ],
  56                                 'MediaWiki:Common.css' => [ 'type' => 'style' ]
  57                         ] ],
  58                         [ $params, new HashConfig( [ 'UseSiteCss' => false ] + $settings ), [
  59                                 'MediaWiki:Common.js' => [ 'type' => 'script' ],
  60                         ] ],
  61                         [ $params, new HashConfig( [ 'UseSiteJs' => false ] + $settings ), [
  62                                 'MediaWiki:Common.css' => [ 'type' => 'style' ],
  63                         ] ],
  64                         [ $params,
  65                                 new HashConfig(
  66                                         [ 'UseSiteJs' => false, 'UseSiteCss' => false ]
  67                                 ),
  68                                 []
  69                         ],
  70                 ];
  71         }
  72
  73         /**
  74          * @covers ResourceLoaderWikiModule::getGroup
  75          * @dataProvider provideGetGroup
  76          */
  77         public function testGetGroup( $params, $expected ) {
  78                 $module = new ResourceLoaderWikiModule( $params );
  79                 $this->assertEquals( $expected, $module->getGroup() );
  80         }
  81
  82         public static function provideGetGroup() {
  83                 return [
  84                         // No group specified
  85                         [ [], null ],
  86                         // A random group
  87                         [ [ 'group' => 'foobar' ], 'foobar' ],
  88                 ];
  89         }
  90
  91         /**
  92          * @covers ResourceLoaderWikiModule::isKnownEmpty
  93          * @dataProvider provideIsKnownEmpty
  94          */
  95         public function testIsKnownEmpty( $titleInfo, $group, $expected ) {
  96                 $module = $this->getMockBuilder( 'ResourceLoaderWikiModule' )
  97                         ->setMethods( [ 'getTitleInfo', 'getGroup' ] )
  98                         ->getMock();
  99                 $module->expects( $this->any() )
 100                         ->method( 'getTitleInfo' )
 101                         ->will( $this->returnValue( $titleInfo ) );
 102                 $module->expects( $this->any() )
 103                         ->method( 'getGroup' )
 104                         ->will( $this->returnValue( $group ) );
 105                 $context = $this->getMockBuilder( 'ResourceLoaderContext' )
 106                         ->disableOriginalConstructor()
 107                         ->getMock();
 108                 $this->assertEquals( $expected, $module->isKnownEmpty( $context ) );
 109         }
 110
 111         public static function provideIsKnownEmpty() {
 112                 return [
 113                         // No valid pages
 114                         [ [], 'test1', true ],
 115                         // 'site' module with a non-empty page
 116                         [
 117                                 [ 'MediaWiki:Common.js' => [ 'page_len' => 1234 ] ],
 118                                 'site',
 119                                 false,
 120                         ],
 121                         // 'site' module with an empty page
 122                         [
 123                                 [ 'MediaWiki:Foo.js' => [ 'page_len' => 0 ] ],
 124                                 'site',
 125                                 false,
 126                         ],
 127                         // 'user' module with a non-empty page
 128                         [
 129                                 [ 'User:Example/common.js' => [ 'page_len' => 25 ] ],
 130                                 'user',
 131                                 false,
 132                         ],
 133                         // 'user' module with an empty page
 134                         [
 135                                 [ 'User:Example/foo.js' => [ 'page_len' => 0 ] ],
 136                                 'user',
 137                                 true,
 138                         ],
 139                 ];
 140         }
 141
 142         /**
 143          * @covers ResourceLoaderWikiModule::getTitleInfo
 144          */
 145         public function testGetTitleInfo() {
 146                 $pages = [
 147                         'MediaWiki:Common.css' => [ 'type' => 'styles' ],
 148                         'mediawiki: fallback.css' => [ 'type' => 'styles' ],
 149                 ];
 150                 $titleInfo = [
 151                         'MediaWiki:Common.css' => [ 'page_len' => 1234 ],
 152                         'MediaWiki:Fallback.css' => [ 'page_len' => 0 ],
 153                 ];
 154                 $expected = $titleInfo;
 155
 156                 $module = $this->getMockBuilder( 'TestResourceLoaderWikiModule' )
 157                         ->setMethods( [ 'getPages' ] )
 158                         ->getMock();
 159                 $module->method( 'getPages' )->willReturn( $pages );
 160                 // Can't mock static methods
 161                 $module::$returnFetchTitleInfo = $titleInfo;
 162
 163                 $context = $this->getMockBuilder( 'ResourceLoaderContext' )
 164                         ->disableOriginalConstructor()
 165                         ->getMock();
 166
 167                 $module = TestingAccessWrapper::newFromObject( $module );
 168                 $this->assertEquals( $expected, $module->getTitleInfo( $context ), 'Title info' );
 169         }
 170
 171         /**
 172          * @covers ResourceLoaderWikiModule::getTitleInfo
 173          * @covers ResourceLoaderWikiModule::setTitleInfo
 174          * @covers ResourceLoaderWikiModule::preloadTitleInfo
 175          */
 176         public function testGetPreloadedTitleInfo() {
 177                 $pages = [
 178                         'MediaWiki:Common.css' => [ 'type' => 'styles' ],
 179                         // Regression against T145673. It's impossible to statically declare page names in
 180                         // a canonical way since the canonical prefix is localised. As such, the preload
 181                         // cache computed the right cache key, but failed to find the results when
 182                         // doing an intersect on the canonical result, producing an empty array.
 183                         'mediawiki: fallback.css' => [ 'type' => 'styles' ],
 184                 ];
 185                 $titleInfo = [
 186                         'MediaWiki:Common.css' => [ 'page_len' => 1234 ],
 187                         'MediaWiki:Fallback.css' => [ 'page_len' => 0 ],
 188                 ];
 189                 $expected = $titleInfo;
 190
 191                 $module = $this->getMockBuilder( 'TestResourceLoaderWikiModule' )
 192                         ->setMethods( [ 'getPages' ] )
 193                         ->getMock();
 194                 $module->method( 'getPages' )->willReturn( $pages );
 195                 // Can't mock static methods
 196                 $module::$returnFetchTitleInfo = $titleInfo;
 197
 198                 $rl = new EmptyResourceLoader();
 199                 $rl->register( 'testmodule', $module );
 200                 $context = new ResourceLoaderContext( $rl, new FauxRequest() );
 201
 202                 TestResourceLoaderWikiModule::invalidateModuleCache(
 203                         Title::newFromText( 'MediaWiki:Common.css' ),
 204                         null,
 205                         null,
 206                         wfWikiID()
 207                 );
 208                 TestResourceLoaderWikiModule::preloadTitleInfo(
 209                         $context,
 210                         wfGetDB( DB_REPLICA ),
 211                         [ 'testmodule' ]
 212                 );
 213
 214                 $module = TestingAccessWrapper::newFromObject( $module );
 215                 $this->assertEquals( $expected, $module->getTitleInfo( $context ), 'Title info' );
 216         }
 217 }
 218
 219 class TestResourceLoaderWikiModule extends ResourceLoaderWikiModule {
 220         public static $returnFetchTitleInfo = null;
 221         protected static function fetchTitleInfo( IDatabase $db, array $pages, $fname = null ) {
 222                 $ret = self::$returnFetchTitleInfo;
 223                 self::$returnFetchTitleInfo = null;
 224                 return $ret;
 225         }
 226 }