tests/phpunit/unit/structure/AutoLoaderStructureTest.php

   1 <?php
   2
   3 /**
   4  * @coversNothing
   5  */
   6 class AutoLoaderStructureTest extends MediaWikiUnitTestCase {
   7
   8         /**
   9          * Assert that there were no classes loaded that are not registered with the AutoLoader.
  10          *
  11          * For example foo.php having class Foo and class Bar but only registering Foo.
  12          * This is important because we should not be relying on Foo being used before Bar.
  13          */
  14         public function testAutoLoadConfig() {
  15                 $results = self::checkAutoLoadConf();
  16
  17                 $this->assertEquals(
  18                         $results['expected'],
  19                         $results['actual']
  20                 );
  21         }
  22
  23         public function providePSR4Completeness() {
  24                 foreach ( AutoLoader::$psr4Namespaces as $prefix => $dir ) {
  25                         foreach ( $this->recurseFiles( $dir ) as $file ) {
  26                                 yield [ $prefix, $dir, $file ];
  27                         }
  28                 }
  29         }
  30
  31         private function recurseFiles( $dir ) {
  32                 return ( new File_Iterator_Facade() )->getFilesAsArray( $dir, [ '.php' ] );
  33         }
  34
  35         /**
  36          * @dataProvider providePSR4Completeness
  37          */
  38         public function testPSR4Completeness( $prefix, $dir, $file ) {
  39                 global $wgAutoloadLocalClasses, $wgAutoloadClasses;
  40                 $contents = file_get_contents( $file );
  41                 list( $classesInFile, $aliasesInFile ) = self::parseFile( $contents );
  42                 $classes = array_keys( $classesInFile );
  43                 if ( $classes ) {
  44                         $this->assertCount(
  45                                 1,
  46                                 $classes,
  47                                 "Only one class per file in PSR-4 autoloaded classes ($file)"
  48                         );
  49
  50                         // Check that the expected class name (based on the filename) is the
  51                         // same as the one we found.
  52                         // Strip directory prefix from front of filename, and .php extension
  53                         $dirNameLength = strlen( realpath( $dir ) ) + 1; // +1 for the trailing slash
  54                         $fileBaseName = substr( $file, $dirNameLength );
  55                         $abbrFileName = substr( $fileBaseName, 0, -4 );
  56                         $expectedClassName = $prefix . str_replace( '/', '\\', $abbrFileName );
  57
  58                         $this->assertSame(
  59                                 $expectedClassName,
  60                                 $classes[0],
  61                                 "Class not autoloaded properly"
  62                         );
  63
  64                 } else {
  65                         // Dummy assertion so this test isn't marked in risky
  66                         // if the file has no classes nor aliases in it
  67                         $this->assertCount( 0, $classes );
  68                 }
  69
  70                 if ( $aliasesInFile ) {
  71                         $otherClasses = $wgAutoloadLocalClasses + $wgAutoloadClasses;
  72                         foreach ( $aliasesInFile as $alias => $class ) {
  73                                 $this->assertArrayHasKey( $alias, $otherClasses,
  74                                         'Alias must be in the classmap autoloader'
  75                                 );
  76                         }
  77                 }
  78         }
  79
  80         private static function parseFile( $contents ) {
  81                 // We could use token_get_all() here, but this is faster
  82                 // Note: Keep in sync with ClassCollector
  83                 $matches = [];
  84                 preg_match_all( '/
  85                                 ^ [\t ]* (?:
  86                                         (?:final\s+)? (?:abstract\s+)? (?:class|interface|trait) \s+
  87                                         (?P<class> \w+)
  88                                 |
  89                                         class_alias \s* \( \s*
  90                                                 ([\'"]) (?P<original> [^\'"]+) \g{-2} \s* , \s*
  91                                                 ([\'"]) (?P<alias> [^\'"]+ ) \g{-2} \s*
  92                                         \) \s* ;
  93                                 |
  94                                         class_alias \s* \( \s*
  95                                                 (?P<originalStatic> [\w\\\\]+)::class \s* , \s*
  96                                                 ([\'"]) (?P<aliasString> [^\'"]+ ) \g{-2} \s*
  97                                         \) \s* ;
  98                                 )
  99                         /imx', $contents, $matches, PREG_SET_ORDER );
 100
 101                 $namespaceMatch = [];
 102                 preg_match( '/
 103                                 ^ [\t ]*
 104                                         namespace \s+
 105                                                 (\w+(\\\\\w+)*)
 106                                         \s* ;
 107                         /imx', $contents, $namespaceMatch );
 108                 $fileNamespace = $namespaceMatch ? $namespaceMatch[1] . '\\' : '';
 109
 110                 $classesInFile = [];
 111                 $aliasesInFile = [];
 112
 113                 foreach ( $matches as $match ) {
 114                         if ( !empty( $match['class'] ) ) {
 115                                 // 'class Foo {}'
 116                                 $class = $fileNamespace . $match['class'];
 117                                 $classesInFile[$class] = true;
 118                         } elseif ( !empty( $match['original'] ) ) {
 119                                 // 'class_alias( "Foo", "Bar" );'
 120                                 $aliasesInFile[$match['alias']] = $match['original'];
 121                         } else {
 122                                 // 'class_alias( Foo::class, "Bar" );'
 123                                 $aliasesInFile[$match['aliasString']] = $fileNamespace . $match['originalStatic'];
 124                         }
 125                 }
 126
 127                 return [ $classesInFile, $aliasesInFile ];
 128         }
 129
 130         protected static function checkAutoLoadConf() {
 131                 global $wgAutoloadLocalClasses, $wgAutoloadClasses, $IP;
 132
 133                 // wgAutoloadLocalClasses has precedence, just like in includes/AutoLoader.php
 134                 $expected = $wgAutoloadLocalClasses + $wgAutoloadClasses;
 135                 $actual = [];
 136
 137                 $psr4Namespaces = [];
 138                 foreach ( AutoLoader::getAutoloadNamespaces() as $ns => $path ) {
 139                         $psr4Namespaces[rtrim( $ns, '\\' ) . '\\'] = rtrim( $path, '/' );
 140                 }
 141
 142                 foreach ( $expected as $class => $file ) {
 143                         // Only prefix $IP if it doesn't have it already.
 144                         // Generally local classes don't have it, and those from extensions and test suites do.
 145                         if ( substr( $file, 0, 1 ) != '/' && substr( $file, 1, 1 ) != ':' ) {
 146                                 $filePath = "$IP/$file";
 147                         } else {
 148                                 $filePath = $file;
 149                         }
 150
 151                         if ( !file_exists( $filePath ) ) {
 152                                 $actual[$class] = "[file '$filePath' does not exist]";
 153                                 continue;
 154                         }
 155
 156                         Wikimedia\suppressWarnings();
 157                         $contents = file_get_contents( $filePath );
 158                         Wikimedia\restoreWarnings();
 159
 160                         if ( $contents === false ) {
 161                                 $actual[$class] = "[couldn't read file '$filePath']";
 162                                 continue;
 163                         }
 164
 165                         list( $classesInFile, $aliasesInFile ) = self::parseFile( $contents );
 166
 167                         foreach ( $classesInFile as $className => $ignore ) {
 168                                 // Skip if it's a PSR4 class
 169                                 $parts = explode( '\\', $className );
 170                                 for ( $i = count( $parts ) - 1; $i > 0; $i-- ) {
 171                                         $ns = implode( '\\', array_slice( $parts, 0, $i ) ) . '\\';
 172                                         if ( isset( $psr4Namespaces[$ns] ) ) {
 173                                                 $expectedPath = $psr4Namespaces[$ns] . '/'
 174                                                         . implode( '/', array_slice( $parts, $i ) )
 175                                                         . '.php';
 176                                                 if ( $filePath === $expectedPath ) {
 177                                                         continue 2;
 178                                                 }
 179                                         }
 180                                 }
 181
 182                                 // Nope, add it.
 183                                 $actual[$className] = $file;
 184                         }
 185
 186                         // Only accept aliases for classes in the same file, because for correct
 187                         // behavior, all aliases for a class must be set up when the class is loaded
 188                         // (see <https://bugs.php.net/bug.php?id=61422>).
 189                         foreach ( $aliasesInFile as $alias => $class ) {
 190                                 if ( isset( $classesInFile[$class] ) ) {
 191                                         $actual[$alias] = $file;
 192                                 } else {
 193                                         $actual[$alias] = "[original class not in $file]";
 194                                 }
 195                         }
 196                 }
 197
 198                 return [
 199                         'expected' => $expected,
 200                         'actual' => $actual,
 201                 ];
 202         }
 203
 204         public function testAutoloadOrder() {
 205                 $path = realpath( __DIR__ . '/../../../..' );
 206                 $oldAutoload = file_get_contents( $path . '/autoload.php' );
 207                 $generator = new AutoloadGenerator( $path, 'local' );
 208                 $generator->setPsr4Namespaces( AutoLoader::getAutoloadNamespaces() );
 209                 $generator->initMediaWikiDefault();
 210                 $newAutoload = $generator->getAutoload( 'maintenance/generateLocalAutoload.php' );
 211
 212                 $this->assertEquals( $oldAutoload, $newAutoload, 'autoload.php does not match' .
 213                         ' output of generateLocalAutoload.php script.' );
 214         }
 215 }