1
0
Fork 0
composer/tests/Composer/Test/Autoload/AutoloadGeneratorTest.php

1989 lines
85 KiB
PHP
Raw Normal View History

2022-02-23 15:58:18 +00:00
<?php declare(strict_types=1);
2011-12-03 22:20:06 +00:00
/*
* This file is part of Composer.
*
* (c) Nils Adermann <naderman@naderman.de>
* Jordi Boggiano <j.boggiano@seld.be>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
2012-03-08 13:17:22 +00:00
namespace Composer\Test\Autoload;
2011-12-03 22:20:06 +00:00
use Composer\Autoload\AutoloadGenerator;
use Composer\Filter\PlatformRequirementFilter\PlatformRequirementFilterFactory;
use Composer\Package\CompletePackage;
use Composer\Package\Link;
use Composer\Package\Version\VersionParser;
use Composer\Semver\Constraint\Constraint;
2020-06-05 14:41:37 +00:00
use Composer\Semver\Constraint\MatchAllConstraint;
use Composer\Util\Filesystem;
2012-05-14 12:01:37 +00:00
use Composer\Package\AliasPackage;
use Composer\Package\Package;
use Composer\Package\RootPackage;
use Composer\Test\TestCase;
2013-01-06 19:34:52 +00:00
use Composer\Script\ScriptEvents;
use Composer\Repository\InstalledRepositoryInterface;
use Composer\Installer\InstallationManager;
use Composer\Config;
use Composer\EventDispatcher\EventDispatcher;
use Composer\Util\Platform;
2021-12-08 16:03:05 +00:00
use PHPUnit\Framework\MockObject\MockObject;
2011-12-03 22:20:06 +00:00
class AutoloadGeneratorTest extends TestCase
2011-12-03 22:20:06 +00:00
{
/**
* @var string
*/
2011-12-03 22:20:06 +00:00
public $vendorDir;
/**
* @var Config|MockObject
*/
private $config;
/**
* @var string
*/
2011-12-03 22:20:06 +00:00
private $workingDir;
/**
* @var string
*/
private $origDir;
/**
2021-12-08 16:03:05 +00:00
* @var InstallationManager&MockObject
*/
2011-12-03 22:20:06 +00:00
private $im;
/**
2021-12-08 16:03:05 +00:00
* @var InstalledRepositoryInterface&MockObject
*/
2011-12-03 22:20:06 +00:00
private $repository;
/**
* @var AutoloadGenerator
*/
2011-12-03 22:20:06 +00:00
private $generator;
/**
* @var Filesystem
*/
private $fs;
/**
2021-12-08 16:03:05 +00:00
* @var EventDispatcher&MockObject
*/
2013-01-06 19:34:52 +00:00
private $eventDispatcher;
2011-12-03 22:20:06 +00:00
/**
* Map of setting name => return value configuration for the stub Config
* object.
*
* @var array<string, callable|boolean>
*/
private $configValueMap;
2021-12-08 16:03:05 +00:00
protected function setUp(): void
2011-12-03 22:20:06 +00:00
{
$this->fs = new Filesystem;
2011-12-03 22:20:06 +00:00
$this->workingDir = self::getUniqueTmpDirectory();
2013-02-20 15:50:26 +00:00
$this->vendorDir = $this->workingDir.DIRECTORY_SEPARATOR.'composer-test-autoload';
$this->ensureDirectoryExistsAndClear($this->vendorDir);
2011-12-03 22:20:06 +00:00
$this->config = $this->getMockBuilder('Composer\Config')->getMock();
2022-08-17 12:20:07 +00:00
$this->configValueMap = [
2022-02-21 12:42:28 +00:00
'vendor-dir' => function (): string {
2022-01-03 14:40:32 +00:00
return $this->vendorDir;
},
2022-08-17 12:20:07 +00:00
'platform-check' => static function (): bool {
return true;
},
2022-08-17 12:20:07 +00:00
'use-include-path' => static function (): bool {
2022-04-28 19:20:40 +00:00
return false;
},
2022-08-17 12:20:07 +00:00
];
$this->config->expects($this->atLeastOnce())
->method('get')
2022-01-03 14:40:32 +00:00
->will($this->returnCallback(function ($arg) {
$ret = null;
2022-01-03 14:40:32 +00:00
if (isset($this->configValueMap[$arg])) {
$ret = $this->configValueMap[$arg];
if (is_callable($ret)) {
$ret = $ret();
}
}
2015-02-24 14:22:54 +00:00
return $ret;
}));
2022-02-22 15:47:09 +00:00
$this->origDir = Platform::getCwd();
2011-12-03 22:20:06 +00:00
chdir($this->workingDir);
$this->im = $this->getMockBuilder('Composer\Installer\InstallationManager')
->disableOriginalConstructor()
->getMock();
$this->im->expects($this->any())
->method('getInstallPath')
->will($this->returnCallback(function ($package): ?string {
if ($package->getType() === 'metapackage') {
return null;
}
$targetDir = $package->getTargetDir();
2013-06-13 11:28:24 +00:00
2022-01-03 14:40:32 +00:00
return $this->vendorDir.'/'.$package->getName() . ($targetDir ? '/'.$targetDir : '');
2011-12-03 22:20:06 +00:00
}));
$this->repository = $this->getMockBuilder('Composer\Repository\InstalledRepositoryInterface')->getMock();
$this->repository->expects($this->any())
->method('getDevPackageNames')
2022-08-17 12:20:07 +00:00
->willReturn([]);
2011-12-03 22:20:06 +00:00
$this->eventDispatcher = $this->getMockBuilder('Composer\EventDispatcher\EventDispatcher')
2013-01-06 19:34:52 +00:00
->disableOriginalConstructor()
->getMock();
$this->generator = new AutoloadGenerator($this->eventDispatcher);
2011-12-03 22:20:06 +00:00
}
2021-12-08 16:03:05 +00:00
protected function tearDown(): void
2011-12-03 22:20:06 +00:00
{
parent::tearDown();
2013-02-20 15:50:26 +00:00
chdir($this->origDir);
if (is_dir($this->workingDir)) {
$this->fs->removeDirectory($this->workingDir);
}
if (is_dir($this->vendorDir)) {
$this->fs->removeDirectory($this->vendorDir);
}
2011-12-03 22:20:06 +00:00
}
public function testRootPackageAutoloading(): void
2011-12-03 22:20:06 +00:00
{
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$package->setAutoload([
'psr-0' => [
'Main' => 'src/',
2022-08-17 12:20:07 +00:00
'Lala' => ['src/', 'lib/'],
],
'psr-4' => [
'Acme\Fruit\\' => 'src-fruit/',
2022-08-17 12:20:07 +00:00
'Acme\Cake\\' => ['src-cake/', 'lib-cake/'],
],
'classmap' => ['composersrc/'],
]);
2011-12-03 22:20:06 +00:00
$this->repository->expects($this->once())
->method('getCanonicalPackages')
2022-08-17 12:20:07 +00:00
->will($this->returnValue([]));
2011-12-03 22:20:06 +00:00
$this->fs->ensureDirectoryExists($this->workingDir.'/composer');
$this->fs->ensureDirectoryExists($this->workingDir.'/src/Lala/Test');
$this->fs->ensureDirectoryExists($this->workingDir.'/lib');
2014-02-03 15:53:56 +00:00
file_put_contents($this->workingDir.'/src/Lala/ClassMapMain.php', '<?php namespace Lala; class ClassMapMain {}');
file_put_contents($this->workingDir.'/src/Lala/Test/ClassMapMainTest.php', '<?php namespace Lala\Test; class ClassMapMainTest {}');
$this->fs->ensureDirectoryExists($this->workingDir.'/src-fruit');
$this->fs->ensureDirectoryExists($this->workingDir.'/src-cake');
$this->fs->ensureDirectoryExists($this->workingDir.'/lib-cake');
2014-02-03 15:53:56 +00:00
file_put_contents($this->workingDir.'/src-cake/ClassMapBar.php', '<?php namespace Acme\Cake; class ClassMapBar {}');
$this->fs->ensureDirectoryExists($this->workingDir.'/composersrc');
file_put_contents($this->workingDir.'/composersrc/foo.php', '<?php class ClassMapFoo {}');
2014-02-03 15:53:56 +00:00
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', true, '_1');
// Assert that autoload_namespaces.php was correctly generated.
$this->assertAutoloadFiles('main', $this->vendorDir.'/composer');
// Assert that autoload_psr4.php was correctly generated.
$this->assertAutoloadFiles('psr4', $this->vendorDir.'/composer', 'psr4');
// Assert that autoload_classmap.php was correctly generated.
$this->assertAutoloadFiles('classmap', $this->vendorDir.'/composer', 'classmap');
2011-12-03 22:20:06 +00:00
}
public function testRootPackageDevAutoloading(): void
2014-02-27 09:39:33 +00:00
{
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$package->setAutoload([
'psr-0' => [
2014-02-27 09:39:33 +00:00
'Main' => 'src/',
2022-08-17 12:20:07 +00:00
],
]);
$package->setDevAutoload([
'files' => ['devfiles/foo.php'],
'psr-0' => [
2015-09-28 09:51:14 +00:00
'Main' => 'tests/',
2022-08-17 12:20:07 +00:00
],
]);
2014-02-27 09:39:33 +00:00
$this->repository->expects($this->once())
->method('getCanonicalPackages')
2022-08-17 12:20:07 +00:00
->will($this->returnValue([]));
2014-02-27 09:39:33 +00:00
$this->fs->ensureDirectoryExists($this->workingDir.'/composer');
$this->fs->ensureDirectoryExists($this->workingDir.'/src/Main');
file_put_contents($this->workingDir.'/src/Main/ClassMain.php', '<?php namespace Main; class ClassMain {}');
$this->fs->ensureDirectoryExists($this->workingDir.'/devfiles');
file_put_contents($this->workingDir.'/devfiles/foo.php', '<?php function foo() { echo "foo"; }');
// generate autoload files with the dev mode set to true
$this->generator->setDevMode(true);
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', true, '_1');
2014-02-27 09:39:33 +00:00
// check standard autoload
$this->assertAutoloadFiles('main5', $this->vendorDir.'/composer');
2014-02-27 09:39:33 +00:00
$this->assertAutoloadFiles('classmap7', $this->vendorDir.'/composer', 'classmap');
2014-02-27 09:39:33 +00:00
// make sure dev autoload is correctly dumped
$this->assertAutoloadFiles('files2', $this->vendorDir.'/composer', 'files');
}
public function testRootPackageDevAutoloadingDisabledByDefault(): void
2014-02-27 09:39:33 +00:00
{
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$package->setAutoload([
'psr-0' => [
2014-02-27 09:39:33 +00:00
'Main' => 'src/',
2022-08-17 12:20:07 +00:00
],
]);
$package->setDevAutoload([
'files' => ['devfiles/foo.php'],
]);
2011-12-03 22:20:06 +00:00
2014-02-27 09:39:33 +00:00
$this->repository->expects($this->once())
->method('getCanonicalPackages')
2022-08-17 12:20:07 +00:00
->will($this->returnValue([]));
2014-02-27 09:39:33 +00:00
$this->fs->ensureDirectoryExists($this->workingDir.'/composer');
$this->fs->ensureDirectoryExists($this->workingDir.'/src/Main');
file_put_contents($this->workingDir.'/src/Main/ClassMain.php', '<?php namespace Main; class ClassMain {}');
$this->fs->ensureDirectoryExists($this->workingDir.'/devfiles');
file_put_contents($this->workingDir.'/devfiles/foo.php', '<?php function foo() { echo "foo"; }');
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', true, '_1');
// check standard autoload
$this->assertAutoloadFiles('main4', $this->vendorDir.'/composer');
$this->assertAutoloadFiles('classmap7', $this->vendorDir.'/composer', 'classmap');
// make sure dev autoload is disabled when dev mode is set to false
$this->assertFalse(is_file($this->vendorDir.'/composer/autoload_files.php'));
}
public function testVendorDirSameAsWorkingDir(): void
2012-01-31 14:04:49 +00:00
{
$this->vendorDir = $this->workingDir;
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$package->setAutoload([
'psr-0' => ['Main' => 'src/', 'Lala' => 'src/'],
'psr-4' => [
'Acme\Fruit\\' => 'src-fruit/',
2022-08-17 12:20:07 +00:00
'Acme\Cake\\' => ['src-cake/', 'lib-cake/'],
],
'classmap' => ['composersrc/'],
]);
$this->repository->expects($this->once())
->method('getCanonicalPackages')
2022-08-17 12:20:07 +00:00
->will($this->returnValue([]));
$this->fs->ensureDirectoryExists($this->vendorDir.'/composer');
$this->fs->ensureDirectoryExists($this->vendorDir.'/src/Main');
file_put_contents($this->vendorDir.'/src/Main/Foo.php', '<?php namespace Main; class Foo {}');
$this->fs->ensureDirectoryExists($this->vendorDir.'/composersrc');
file_put_contents($this->vendorDir.'/composersrc/foo.php', '<?php class ClassMapFoo {}');
2012-08-14 18:28:49 +00:00
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', true, '_2');
$this->assertAutoloadFiles('main3', $this->vendorDir.'/composer');
$this->assertAutoloadFiles('psr4_3', $this->vendorDir.'/composer', 'psr4');
$this->assertAutoloadFiles('classmap3', $this->vendorDir.'/composer', 'classmap');
2012-01-31 14:04:49 +00:00
}
public function testRootPackageAutoloadingAlternativeVendorDir(): void
2011-12-03 22:20:06 +00:00
{
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$package->setAutoload([
'psr-0' => ['Main' => 'src/', 'Lala' => 'src/'],
'psr-4' => [
'Acme\Fruit\\' => 'src-fruit/',
2022-08-17 12:20:07 +00:00
'Acme\Cake\\' => ['src-cake/', 'lib-cake/'],
],
'classmap' => ['composersrc/'],
]);
2011-12-03 22:20:06 +00:00
$this->repository->expects($this->once())
->method('getCanonicalPackages')
2022-08-17 12:20:07 +00:00
->will($this->returnValue([]));
2011-12-03 22:20:06 +00:00
$this->vendorDir .= '/subdir';
$this->fs->ensureDirectoryExists($this->vendorDir.'/composer');
$this->fs->ensureDirectoryExists($this->workingDir.'/src');
$this->fs->ensureDirectoryExists($this->workingDir.'/composersrc');
file_put_contents($this->workingDir.'/composersrc/foo.php', '<?php class ClassMapFoo {}');
2012-08-14 18:28:49 +00:00
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', false, '_3');
$this->assertAutoloadFiles('main2', $this->vendorDir.'/composer');
$this->assertAutoloadFiles('psr4_2', $this->vendorDir.'/composer', 'psr4');
$this->assertAutoloadFiles('classmap2', $this->vendorDir.'/composer', 'classmap');
2011-12-03 22:20:06 +00:00
}
public function testRootPackageAutoloadingWithTargetDir(): void
{
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$package->setAutoload([
'psr-0' => ['Main\\Foo' => '', 'Main\\Bar' => ''],
'classmap' => ['Main/Foo/src', 'lib'],
'files' => ['foo.php', 'Main/Foo/bar.php'],
]);
2012-04-19 20:04:49 +00:00
$package->setTargetDir('Main/Foo/');
$this->repository->expects($this->once())
->method('getCanonicalPackages')
2022-08-17 12:20:07 +00:00
->will($this->returnValue([]));
$this->fs->ensureDirectoryExists($this->vendorDir.'/a');
$this->fs->ensureDirectoryExists($this->workingDir.'/src');
$this->fs->ensureDirectoryExists($this->workingDir.'/lib');
file_put_contents($this->workingDir.'/src/rootfoo.php', '<?php class ClassMapFoo {}');
file_put_contents($this->workingDir.'/lib/rootbar.php', '<?php class ClassMapBar {}');
file_put_contents($this->workingDir.'/foo.php', '<?php class FilesFoo {}');
file_put_contents($this->workingDir.'/bar.php', '<?php class FilesBar {}');
2012-08-14 18:28:49 +00:00
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', false, 'TargetDir');
2020-02-07 03:18:45 +00:00
$this->assertFileContentEquals(__DIR__.'/Fixtures/autoload_target_dir.php', $this->vendorDir.'/autoload.php');
$this->assertFileContentEquals(__DIR__.'/Fixtures/autoload_real_target_dir.php', $this->vendorDir.'/composer/autoload_real.php');
$this->assertFileContentEquals(__DIR__.'/Fixtures/autoload_static_target_dir.php', $this->vendorDir.'/composer/autoload_static.php');
$this->assertFileContentEquals(__DIR__.'/Fixtures/autoload_files_target_dir.php', $this->vendorDir.'/composer/autoload_files.php');
$this->assertAutoloadFiles('classmap6', $this->vendorDir.'/composer', 'classmap');
}
public function testVendorsAutoloading(): void
2011-12-03 22:20:06 +00:00
{
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$package->setRequires([
'a/a' => new Link('a', 'a/a', new MatchAllConstraint()),
'b/b' => new Link('a', 'b/b', new MatchAllConstraint()),
2022-08-17 12:20:07 +00:00
]);
2011-12-03 22:20:06 +00:00
2022-08-17 12:20:07 +00:00
$packages = [];
$packages[] = $a = new Package('a/a', '1.0', '1.0');
$packages[] = $b = new Package('b/b', '1.0', '1.0');
2012-05-14 12:01:37 +00:00
$packages[] = $c = new AliasPackage($b, '1.2', '1.2');
2022-08-17 12:20:07 +00:00
$a->setAutoload(['psr-0' => ['A' => 'src/', 'A\\B' => 'lib/']]);
$b->setAutoload(['psr-0' => ['B\\Sub\\Name' => 'src/']]);
2011-12-03 22:20:06 +00:00
$this->repository->expects($this->once())
->method('getCanonicalPackages')
2011-12-03 22:20:06 +00:00
->will($this->returnValue($packages));
$this->fs->ensureDirectoryExists($this->vendorDir.'/composer');
$this->fs->ensureDirectoryExists($this->vendorDir.'/a/a/src');
$this->fs->ensureDirectoryExists($this->vendorDir.'/a/a/lib');
$this->fs->ensureDirectoryExists($this->vendorDir.'/b/b/src');
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', false, '_5');
$this->assertAutoloadFiles('vendors', $this->vendorDir.'/composer');
$this->assertFileExists($this->vendorDir.'/composer/autoload_classmap.php', "ClassMap file needs to be generated, even if empty.");
}
public function testVendorsAutoloadingWithMetapackages(): void
{
$package = new RootPackage('root/a', '1.0', '1.0');
$package->setRequires([
'a/a' => new Link('a', 'a/a', new MatchAllConstraint()),
]);
$packages = [];
$packages[] = $a = new Package('a/a', '1.0', '1.0');
$packages[] = $b = new Package('b/b', '1.0', '1.0');
$packages[] = $c = new AliasPackage($b, '1.2', '1.2');
$a->setAutoload(['psr-0' => ['A' => 'src/', 'A\\B' => 'lib/']]);
$b->setAutoload(['psr-0' => ['B\\Sub\\Name' => 'src/']]);
$a->setType('metapackage');
$a->setRequires([
'b/b' => new Link('a/a', 'b/b', new MatchAllConstraint()),
]);
$this->repository->expects($this->once())
->method('getCanonicalPackages')
->will($this->returnValue($packages));
$this->fs->ensureDirectoryExists($this->vendorDir.'/composer');
$this->fs->ensureDirectoryExists($this->vendorDir.'/b/b/src');
// creating a/a files to make sure they would be found by autoloader even tho they are technically not
// needed as the package is a metapackage, but if it fails to be excluded it would find these
$this->fs->ensureDirectoryExists($this->vendorDir.'/a/a/src');
$this->fs->ensureDirectoryExists($this->vendorDir.'/a/a/lib');
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', false, '_5');
$this->assertAutoloadFiles('vendors_meta', $this->vendorDir.'/composer');
$this->assertFileExists($this->vendorDir.'/composer/autoload_classmap.php', "ClassMap file needs to be generated, even if empty.");
}
public function testNonDevAutoloadExclusionWithRecursion(): void
{
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$package->setRequires([
'a/a' => new Link('a', 'a/a', new MatchAllConstraint()),
2022-08-17 12:20:07 +00:00
]);
2022-08-17 12:20:07 +00:00
$packages = [];
$packages[] = $a = new Package('a/a', '1.0', '1.0');
$packages[] = $b = new Package('b/b', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$a->setAutoload(['psr-0' => ['A' => 'src/', 'A\\B' => 'lib/']]);
$a->setRequires([
'b/b' => new Link('a/a', 'b/b', new MatchAllConstraint()),
2022-08-17 12:20:07 +00:00
]);
$b->setAutoload(['psr-0' => ['B\\Sub\\Name' => 'src/']]);
$b->setRequires([
'a/a' => new Link('b/b', 'a/a', new MatchAllConstraint()),
2022-08-17 12:20:07 +00:00
]);
$this->repository->expects($this->once())
->method('getCanonicalPackages')
->will($this->returnValue($packages));
$this->fs->ensureDirectoryExists($this->vendorDir.'/composer');
$this->fs->ensureDirectoryExists($this->vendorDir.'/a/a/src');
$this->fs->ensureDirectoryExists($this->vendorDir.'/a/a/lib');
$this->fs->ensureDirectoryExists($this->vendorDir.'/b/b/src');
2012-08-14 18:28:49 +00:00
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', false, '_5');
$this->assertAutoloadFiles('vendors', $this->vendorDir.'/composer');
2017-11-30 14:58:10 +00:00
$this->assertFileExists($this->vendorDir.'/composer/autoload_classmap.php', "ClassMap file needs to be generated, even if empty.");
2012-03-05 13:10:01 +00:00
}
public function testNonDevAutoloadShouldIncludeReplacedPackages(): void
{
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$package->setRequires(['a/a' => new Link('a', 'a/a', new MatchAllConstraint())]);
2022-08-17 12:20:07 +00:00
$packages = [];
$packages[] = $a = new Package('a/a', '1.0', '1.0');
$packages[] = $b = new Package('b/b', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$a->setRequires(['b/c' => new Link('a/a', 'b/c', new MatchAllConstraint())]);
2022-08-17 12:20:07 +00:00
$b->setAutoload(['psr-4' => ['B\\' => 'src/']]);
$b->setReplaces(
2022-08-17 12:20:07 +00:00
['b/c' => new Link('b/b', 'b/c', new Constraint('==', '1.0'), Link::TYPE_REPLACE)]
);
$this->repository->expects($this->once())
->method('getCanonicalPackages')
->will($this->returnValue($packages));
$this->fs->ensureDirectoryExists($this->vendorDir.'/b/b/src/C');
file_put_contents($this->vendorDir.'/b/b/src/C/C.php', '<?php namespace B\\C; class C {}');
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', true, '_5');
$this->assertEquals(
2022-08-17 12:20:07 +00:00
[
'B\\C\\C' => $this->vendorDir.'/b/b/src/C/C.php',
'Composer\\InstalledVersions' => $this->vendorDir . '/composer/InstalledVersions.php',
2022-08-17 12:20:07 +00:00
],
include $this->vendorDir.'/composer/autoload_classmap.php'
);
}
public function testNonDevAutoloadExclusionWithRecursionReplace(): void
{
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$package->setRequires([
'a/a' => new Link('a', 'a/a', new MatchAllConstraint()),
2022-08-17 12:20:07 +00:00
]);
2022-08-17 12:20:07 +00:00
$packages = [];
$packages[] = $a = new Package('a/a', '1.0', '1.0');
$packages[] = $b = new Package('b/b', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$a->setAutoload(['psr-0' => ['A' => 'src/', 'A\\B' => 'lib/']]);
$a->setRequires([
'c/c' => new Link('a/a', 'c/c', new MatchAllConstraint()),
2022-08-17 12:20:07 +00:00
]);
$b->setAutoload(['psr-0' => ['B\\Sub\\Name' => 'src/']]);
$b->setReplaces([
'c/c' => new Link('b/b', 'c/c', new MatchAllConstraint()),
2022-08-17 12:20:07 +00:00
]);
$this->repository->expects($this->once())
->method('getCanonicalPackages')
->will($this->returnValue($packages));
$this->fs->ensureDirectoryExists($this->vendorDir.'/composer');
$this->fs->ensureDirectoryExists($this->vendorDir.'/a/a/src');
$this->fs->ensureDirectoryExists($this->vendorDir.'/a/a/lib');
$this->fs->ensureDirectoryExists($this->vendorDir.'/b/b/src');
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', false, '_5');
$this->assertAutoloadFiles('vendors', $this->vendorDir.'/composer');
$this->assertFileExists($this->vendorDir.'/composer/autoload_classmap.php', "ClassMap file needs to be generated, even if empty.");
}
public function testNonDevAutoloadReplacesNestedRequirements(): void
2020-02-24 12:43:00 +00:00
{
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$package->setRequires([
'a/a' => new Link('a', 'a/a', new MatchAllConstraint()),
2022-08-17 12:20:07 +00:00
]);
2020-02-24 12:43:00 +00:00
2022-08-17 12:20:07 +00:00
$packages = [];
2020-02-24 12:43:00 +00:00
$packages[] = $a = new Package('a/a', '1.0', '1.0');
$packages[] = $b = new Package('b/b', '1.0', '1.0');
$packages[] = $c = new Package('c/c', '1.0', '1.0');
$packages[] = $d = new Package('d/d', '1.0', '1.0');
$packages[] = $e = new Package('e/e', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$a->setAutoload(['classmap' => ['src/A.php']]);
$a->setRequires([
'b/b' => new Link('a/a', 'b/b', new MatchAllConstraint()),
2022-08-17 12:20:07 +00:00
]);
$b->setAutoload(['classmap' => ['src/B.php']]);
$b->setRequires([
'e/e' => new Link('b/b', 'e/e', new MatchAllConstraint()),
2022-08-17 12:20:07 +00:00
]);
$c->setAutoload(['classmap' => ['src/C.php']]);
$c->setReplaces([
'b/b' => new Link('c/c', 'b/b', new MatchAllConstraint()),
2022-08-17 12:20:07 +00:00
]);
$c->setRequires([
'd/d' => new Link('c/c', 'd/d', new MatchAllConstraint()),
2022-08-17 12:20:07 +00:00
]);
$d->setAutoload(['classmap' => ['src/D.php']]);
$e->setAutoload(['classmap' => ['src/E.php']]);
2020-02-24 12:43:00 +00:00
$this->repository->expects($this->once())
->method('getCanonicalPackages')
->will($this->returnValue($packages));
$this->fs->ensureDirectoryExists($this->vendorDir.'/a/a/src');
$this->fs->ensureDirectoryExists($this->vendorDir.'/b/b/src');
$this->fs->ensureDirectoryExists($this->vendorDir.'/c/c/src');
$this->fs->ensureDirectoryExists($this->vendorDir.'/d/d/src');
$this->fs->ensureDirectoryExists($this->vendorDir.'/e/e/src');
file_put_contents($this->vendorDir.'/a/a/src/A.php', '<?php class A {}');
file_put_contents($this->vendorDir.'/b/b/src/B.php', '<?php class B {}');
file_put_contents($this->vendorDir.'/c/c/src/C.php', '<?php class C {}');
file_put_contents($this->vendorDir.'/d/d/src/D.php', '<?php class D {}');
file_put_contents($this->vendorDir.'/e/e/src/E.php', '<?php class E {}');
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', false, '_5');
$this->assertAutoloadFiles('classmap9', $this->vendorDir.'/composer', 'classmap');
}
public function testPharAutoload(): void
{
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$package->setRequires([
'a/a' => new Link('a', 'a/a', new MatchAllConstraint()),
2022-08-17 12:20:07 +00:00
]);
2022-08-17 12:20:07 +00:00
$package->setAutoload([
'psr-0' => [
'Foo' => 'foo.phar',
'Bar' => 'dir/bar.phar/src',
2022-08-17 12:20:07 +00:00
],
'psr-4' => [
'Baz\\' => 'baz.phar',
'Qux\\' => 'dir/qux.phar/src',
2022-08-17 12:20:07 +00:00
],
]);
$vendorPackage = new Package('a/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$vendorPackage->setAutoload([
'psr-0' => [
'Lorem' => 'lorem.phar',
'Ipsum' => 'dir/ipsum.phar/src',
2022-08-17 12:20:07 +00:00
],
'psr-4' => [
'Dolor\\' => 'dolor.phar',
'Sit\\' => 'dir/sit.phar/src',
2022-08-17 12:20:07 +00:00
],
]);
$this->repository->expects($this->once())
->method('getCanonicalPackages')
2022-08-17 12:20:07 +00:00
->will($this->returnValue([$vendorPackage]));
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', true, 'Phar');
$this->assertAutoloadFiles('phar', $this->vendorDir . '/composer');
$this->assertAutoloadFiles('phar_psr4', $this->vendorDir . '/composer', 'psr4');
$this->assertAutoloadFiles('phar_static', $this->vendorDir . '/composer', 'static');
}
public function testPSRToClassMapIgnoresNonExistingDir(): void
{
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$package->setAutoload([
'psr-0' => ['Prefix' => 'foo/bar/non/existing/'],
'psr-4' => ['Prefix\\' => 'foo/bar/non/existing2/'],
]);
$this->repository->expects($this->once())
->method('getCanonicalPackages')
2022-08-17 12:20:07 +00:00
->will($this->returnValue([]));
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', true, '_8');
2017-11-30 14:58:10 +00:00
$this->assertFileExists($this->vendorDir.'/composer/autoload_classmap.php', "ClassMap file needs to be generated.");
$this->assertEquals(
2022-08-17 12:20:07 +00:00
[
'Composer\\InstalledVersions' => $this->vendorDir.'/composer/InstalledVersions.php',
2022-08-17 12:20:07 +00:00
],
include $this->vendorDir.'/composer/autoload_classmap.php'
);
}
public function testPSRToClassMapIgnoresNonPSRClasses(): void
{
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$package->setAutoload([
'psr-0' => ['psr0_' => 'psr0/'],
'psr-4' => ['psr4\\' => 'psr4/'],
]);
$this->repository->expects($this->once())
->method('getCanonicalPackages')
2022-08-17 12:20:07 +00:00
->will($this->returnValue([]));
$this->fs->ensureDirectoryExists($this->workingDir.'/psr0/psr0');
$this->fs->ensureDirectoryExists($this->workingDir.'/psr4');
file_put_contents($this->workingDir.'/psr0/psr0/match.php', '<?php class psr0_match {}');
file_put_contents($this->workingDir.'/psr0/psr0/badfile.php', '<?php class psr0_badclass {}');
file_put_contents($this->workingDir.'/psr4/match.php', '<?php namespace psr4; class match {}');
file_put_contents($this->workingDir.'/psr4/badfile.php', '<?php namespace psr4; class badclass {}');
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', true, '_1');
$this->assertFileExists($this->vendorDir.'/composer/autoload_classmap.php', "ClassMap file needs to be generated.");
$expectedClassmap = <<<EOF
<?php
// autoload_classmap.php @generated by Composer
2020-11-06 23:08:03 +00:00
\$vendorDir = dirname(__DIR__);
\$baseDir = dirname(\$vendorDir);
return array(
'Composer\\\\InstalledVersions' => \$vendorDir . '/composer/InstalledVersions.php',
'psr0_match' => \$baseDir . '/psr0/psr0/match.php',
'psr4\\\\match' => \$baseDir . '/psr4/match.php',
);
EOF;
$this->assertStringEqualsFile($this->vendorDir.'/composer/autoload_classmap.php', $expectedClassmap);
}
public function testVendorsClassMapAutoloading(): void
2012-03-05 13:10:01 +00:00
{
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$package->setRequires([
'a/a' => new Link('a', 'a/a', new MatchAllConstraint()),
'b/b' => new Link('a', 'b/b', new MatchAllConstraint()),
2022-08-17 12:20:07 +00:00
]);
2012-03-05 13:10:01 +00:00
2022-08-17 12:20:07 +00:00
$packages = [];
$packages[] = $a = new Package('a/a', '1.0', '1.0');
$packages[] = $b = new Package('b/b', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$a->setAutoload(['classmap' => ['src/']]);
$b->setAutoload(['classmap' => ['src/', 'lib/']]);
2012-03-05 13:10:01 +00:00
$this->repository->expects($this->once())
->method('getCanonicalPackages')
2012-03-05 13:10:01 +00:00
->will($this->returnValue($packages));
$this->fs->ensureDirectoryExists($this->vendorDir.'/composer');
$this->fs->ensureDirectoryExists($this->vendorDir.'/a/a/src');
$this->fs->ensureDirectoryExists($this->vendorDir.'/b/b/src');
$this->fs->ensureDirectoryExists($this->vendorDir.'/b/b/lib');
2012-03-05 13:10:01 +00:00
file_put_contents($this->vendorDir.'/a/a/src/a.php', '<?php class ClassMapFoo {}');
file_put_contents($this->vendorDir.'/b/b/src/b.php', '<?php class ClassMapBar {}');
file_put_contents($this->vendorDir.'/b/b/lib/c.php', '<?php class ClassMapBaz {}');
2012-08-14 18:28:49 +00:00
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', false, '_6');
2017-11-30 14:58:10 +00:00
$this->assertFileExists($this->vendorDir.'/composer/autoload_classmap.php', "ClassMap file needs to be generated.");
$this->assertEquals(
2022-08-17 12:20:07 +00:00
[
'ClassMapBar' => $this->vendorDir.'/b/b/src/b.php',
'ClassMapBaz' => $this->vendorDir.'/b/b/lib/c.php',
'ClassMapFoo' => $this->vendorDir.'/a/a/src/a.php',
'Composer\\InstalledVersions' => $this->vendorDir.'/composer/InstalledVersions.php',
2022-08-17 12:20:07 +00:00
],
2013-03-14 09:23:35 +00:00
include $this->vendorDir.'/composer/autoload_classmap.php'
2012-03-05 13:10:01 +00:00
);
$this->assertAutoloadFiles('classmap4', $this->vendorDir.'/composer', 'classmap');
2011-12-03 22:20:06 +00:00
}
public function testVendorsClassMapAutoloadingWithTargetDir(): void
{
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$package->setRequires([
'a/a' => new Link('a', 'a/a', new MatchAllConstraint()),
'b/b' => new Link('a', 'b/b', new MatchAllConstraint()),
2022-08-17 12:20:07 +00:00
]);
2022-08-17 12:20:07 +00:00
$packages = [];
$packages[] = $a = new Package('a/a', '1.0', '1.0');
$packages[] = $b = new Package('b/b', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$a->setAutoload(['classmap' => ['target/src/', 'lib/']]);
$a->setTargetDir('target');
2022-08-17 12:20:07 +00:00
$b->setAutoload(['classmap' => ['src/']]);
$this->repository->expects($this->once())
->method('getCanonicalPackages')
->will($this->returnValue($packages));
$this->fs->ensureDirectoryExists($this->vendorDir.'/composer');
$this->fs->ensureDirectoryExists($this->vendorDir.'/a/a/target/src');
$this->fs->ensureDirectoryExists($this->vendorDir.'/a/a/target/lib');
$this->fs->ensureDirectoryExists($this->vendorDir.'/b/b/src');
file_put_contents($this->vendorDir.'/a/a/target/src/a.php', '<?php class ClassMapFoo {}');
file_put_contents($this->vendorDir.'/a/a/target/lib/b.php', '<?php class ClassMapBar {}');
file_put_contents($this->vendorDir.'/b/b/src/c.php', '<?php class ClassMapBaz {}');
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', false, '_6');
2017-11-30 14:58:10 +00:00
$this->assertFileExists($this->vendorDir.'/composer/autoload_classmap.php', "ClassMap file needs to be generated.");
$this->assertEquals(
2022-08-17 12:20:07 +00:00
[
'ClassMapBar' => $this->vendorDir.'/a/a/target/lib/b.php',
'ClassMapBaz' => $this->vendorDir.'/b/b/src/c.php',
'ClassMapFoo' => $this->vendorDir.'/a/a/target/src/a.php',
'Composer\\InstalledVersions' => $this->vendorDir.'/composer/InstalledVersions.php',
2022-08-17 12:20:07 +00:00
],
2013-03-14 09:23:35 +00:00
include $this->vendorDir.'/composer/autoload_classmap.php'
);
}
public function testClassMapAutoloadingEmptyDirAndExactFile(): void
{
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$package->setRequires([
'a/a' => new Link('a', 'a/a', new MatchAllConstraint()),
'b/b' => new Link('a', 'b/b', new MatchAllConstraint()),
'c/c' => new Link('a', 'c/c', new MatchAllConstraint()),
2022-08-17 12:20:07 +00:00
]);
2022-08-17 12:20:07 +00:00
$packages = [];
$packages[] = $a = new Package('a/a', '1.0', '1.0');
$packages[] = $b = new Package('b/b', '1.0', '1.0');
$packages[] = $c = new Package('c/c', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$a->setAutoload(['classmap' => ['']]);
$b->setAutoload(['classmap' => ['test.php']]);
$c->setAutoload(['classmap' => ['./']]);
$this->repository->expects($this->once())
->method('getCanonicalPackages')
->will($this->returnValue($packages));
$this->fs->ensureDirectoryExists($this->vendorDir.'/composer');
$this->fs->ensureDirectoryExists($this->vendorDir.'/a/a/src');
$this->fs->ensureDirectoryExists($this->vendorDir.'/b/b');
$this->fs->ensureDirectoryExists($this->vendorDir.'/c/c/foo');
file_put_contents($this->vendorDir.'/a/a/src/a.php', '<?php class ClassMapFoo {}');
file_put_contents($this->vendorDir.'/b/b/test.php', '<?php class ClassMapBar {}');
file_put_contents($this->vendorDir.'/c/c/foo/test.php', '<?php class ClassMapBaz {}');
2012-08-14 18:28:49 +00:00
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', false, '_7');
2017-11-30 14:58:10 +00:00
$this->assertFileExists($this->vendorDir.'/composer/autoload_classmap.php', "ClassMap file needs to be generated.");
$this->assertEquals(
2022-08-17 12:20:07 +00:00
[
'ClassMapBar' => $this->vendorDir.'/b/b/test.php',
'ClassMapBaz' => $this->vendorDir.'/c/c/foo/test.php',
'ClassMapFoo' => $this->vendorDir.'/a/a/src/a.php',
'Composer\\InstalledVersions' => $this->vendorDir.'/composer/InstalledVersions.php',
2022-08-17 12:20:07 +00:00
],
2013-03-14 09:23:35 +00:00
include $this->vendorDir.'/composer/autoload_classmap.php'
);
$this->assertAutoloadFiles('classmap5', $this->vendorDir.'/composer', 'classmap');
$this->assertStringNotContainsString('$loader->setClassMapAuthoritative(true);', (string) file_get_contents($this->vendorDir.'/composer/autoload_real.php'));
$this->assertStringNotContainsString('$loader->setApcuPrefix(', (string) file_get_contents($this->vendorDir.'/composer/autoload_real.php'));
}
public function testClassMapAutoloadingAuthoritativeAndApcu(): void
{
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$package->setRequires([
'a/a' => new Link('a', 'a/a', new MatchAllConstraint()),
'b/b' => new Link('a', 'b/b', new MatchAllConstraint()),
'c/c' => new Link('a', 'c/c', new MatchAllConstraint()),
2022-08-17 12:20:07 +00:00
]);
2022-08-17 12:20:07 +00:00
$packages = [];
$packages[] = $a = new Package('a/a', '1.0', '1.0');
$packages[] = $b = new Package('b/b', '1.0', '1.0');
$packages[] = $c = new Package('c/c', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$a->setAutoload(['psr-4' => ['' => 'src/']]);
$b->setAutoload(['psr-4' => ['' => './']]);
$c->setAutoload(['psr-4' => ['' => 'foo/']]);
$this->repository->expects($this->once())
->method('getCanonicalPackages')
->will($this->returnValue($packages));
$this->fs->ensureDirectoryExists($this->vendorDir.'/composer');
$this->fs->ensureDirectoryExists($this->vendorDir.'/a/a/src');
$this->fs->ensureDirectoryExists($this->vendorDir.'/b/b');
$this->fs->ensureDirectoryExists($this->vendorDir.'/c/c/foo');
file_put_contents($this->vendorDir.'/a/a/src/ClassMapFoo.php', '<?php class ClassMapFoo {}');
file_put_contents($this->vendorDir.'/b/b/ClassMapBar.php', '<?php class ClassMapBar {}');
file_put_contents($this->vendorDir.'/c/c/foo/ClassMapBaz.php', '<?php class ClassMapBaz {}');
$this->generator->setClassMapAuthoritative(true);
$this->generator->setApcu(true);
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', false, '_7');
2017-11-30 14:58:10 +00:00
$this->assertFileExists($this->vendorDir.'/composer/autoload_classmap.php', "ClassMap file needs to be generated.");
$this->assertEquals(
2022-08-17 12:20:07 +00:00
[
'ClassMapBar' => $this->vendorDir.'/b/b/ClassMapBar.php',
'ClassMapBaz' => $this->vendorDir.'/c/c/foo/ClassMapBaz.php',
'ClassMapFoo' => $this->vendorDir.'/a/a/src/ClassMapFoo.php',
'Composer\\InstalledVersions' => $this->vendorDir.'/composer/InstalledVersions.php',
2022-08-17 12:20:07 +00:00
],
include $this->vendorDir.'/composer/autoload_classmap.php'
);
$this->assertAutoloadFiles('classmap8', $this->vendorDir.'/composer', 'classmap');
$this->assertStringContainsString('$loader->setClassMapAuthoritative(true);', (string) file_get_contents($this->vendorDir.'/composer/autoload_real.php'));
$this->assertStringContainsString('$loader->setApcuPrefix(', (string) file_get_contents($this->vendorDir.'/composer/autoload_real.php'));
}
public function testClassMapAutoloadingAuthoritativeAndApcuPrefix(): void
{
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$package->setRequires([
'a/a' => new Link('a', 'a/a', new MatchAllConstraint()),
'b/b' => new Link('a', 'b/b', new MatchAllConstraint()),
'c/c' => new Link('a', 'c/c', new MatchAllConstraint()),
2022-08-17 12:20:07 +00:00
]);
2022-08-17 12:20:07 +00:00
$packages = [];
$packages[] = $a = new Package('a/a', '1.0', '1.0');
$packages[] = $b = new Package('b/b', '1.0', '1.0');
$packages[] = $c = new Package('c/c', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$a->setAutoload(['psr-4' => ['' => 'src/']]);
$b->setAutoload(['psr-4' => ['' => './']]);
$c->setAutoload(['psr-4' => ['' => 'foo/']]);
$this->repository->expects($this->once())
->method('getCanonicalPackages')
->will($this->returnValue($packages));
$this->fs->ensureDirectoryExists($this->vendorDir.'/composer');
$this->fs->ensureDirectoryExists($this->vendorDir.'/a/a/src');
$this->fs->ensureDirectoryExists($this->vendorDir.'/b/b');
$this->fs->ensureDirectoryExists($this->vendorDir.'/c/c/foo');
file_put_contents($this->vendorDir.'/a/a/src/ClassMapFoo.php', '<?php class ClassMapFoo {}');
file_put_contents($this->vendorDir.'/b/b/ClassMapBar.php', '<?php class ClassMapBar {}');
file_put_contents($this->vendorDir.'/c/c/foo/ClassMapBaz.php', '<?php class ClassMapBaz {}');
$this->generator->setClassMapAuthoritative(true);
2020-09-16 08:49:00 +00:00
$this->generator->setApcu(true, 'custom\'Prefix');
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', false, '_7');
$this->assertFileExists($this->vendorDir.'/composer/autoload_classmap.php', "ClassMap file needs to be generated.");
$this->assertEquals(
2022-08-17 12:20:07 +00:00
[
'ClassMapBar' => $this->vendorDir.'/b/b/ClassMapBar.php',
'ClassMapBaz' => $this->vendorDir.'/c/c/foo/ClassMapBaz.php',
'ClassMapFoo' => $this->vendorDir.'/a/a/src/ClassMapFoo.php',
'Composer\\InstalledVersions' => $this->vendorDir.'/composer/InstalledVersions.php',
2022-08-17 12:20:07 +00:00
],
include $this->vendorDir.'/composer/autoload_classmap.php'
);
$this->assertAutoloadFiles('classmap8', $this->vendorDir.'/composer', 'classmap');
$this->assertStringContainsString('$loader->setClassMapAuthoritative(true);', (string) file_get_contents($this->vendorDir.'/composer/autoload_real.php'));
$this->assertStringContainsString('$loader->setApcuPrefix(\'custom\\\'Prefix\');', (string) file_get_contents($this->vendorDir.'/composer/autoload_real.php'));
}
public function testFilesAutoloadGeneration(): void
{
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$package->setAutoload(['files' => ['root.php']]);
$package->setRequires([
'a/a' => new Link('a', 'a/a', new MatchAllConstraint()),
'b/b' => new Link('a', 'b/b', new MatchAllConstraint()),
'c/c' => new Link('a', 'c/c', new MatchAllConstraint()),
2022-08-17 12:20:07 +00:00
]);
2022-08-17 12:20:07 +00:00
$packages = [];
$packages[] = $a = new Package('a/a', '1.0', '1.0');
$packages[] = $b = new Package('b/b', '1.0', '1.0');
$packages[] = $c = new Package('c/c', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$a->setAutoload(['files' => ['test.php']]);
$b->setAutoload(['files' => ['test2.php']]);
$c->setAutoload(['files' => ['test3.php', 'foo/bar/test4.php']]);
$c->setTargetDir('foo/bar');
$this->repository->expects($this->once())
->method('getCanonicalPackages')
->will($this->returnValue($packages));
$this->fs->ensureDirectoryExists($this->vendorDir.'/a/a');
$this->fs->ensureDirectoryExists($this->vendorDir.'/b/b');
$this->fs->ensureDirectoryExists($this->vendorDir.'/c/c/foo/bar');
file_put_contents($this->vendorDir.'/a/a/test.php', '<?php function testFilesAutoloadGeneration1() {}');
file_put_contents($this->vendorDir.'/b/b/test2.php', '<?php function testFilesAutoloadGeneration2() {}');
file_put_contents($this->vendorDir.'/c/c/foo/bar/test3.php', '<?php function testFilesAutoloadGeneration3() {}');
file_put_contents($this->vendorDir.'/c/c/foo/bar/test4.php', '<?php function testFilesAutoloadGeneration4() {}');
file_put_contents($this->workingDir.'/root.php', '<?php function testFilesAutoloadGenerationRoot() {}');
2012-08-14 18:28:49 +00:00
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', false, 'FilesAutoload');
2020-02-07 03:18:45 +00:00
$this->assertFileContentEquals(__DIR__.'/Fixtures/autoload_functions.php', $this->vendorDir.'/autoload.php');
$this->assertFileContentEquals(__DIR__.'/Fixtures/autoload_real_functions.php', $this->vendorDir.'/composer/autoload_real.php');
$this->assertFileContentEquals(__DIR__.'/Fixtures/autoload_static_functions.php', $this->vendorDir.'/composer/autoload_static.php');
$this->assertFileContentEquals(__DIR__.'/Fixtures/autoload_files_functions.php', $this->vendorDir.'/composer/autoload_files.php');
$loader = require $this->vendorDir . '/autoload.php';
$loader->unregister();
$this->assertTrue(function_exists('testFilesAutoloadGeneration1'));
$this->assertTrue(function_exists('testFilesAutoloadGeneration2'));
$this->assertTrue(function_exists('testFilesAutoloadGeneration3'));
$this->assertTrue(function_exists('testFilesAutoloadGeneration4'));
$this->assertTrue(function_exists('testFilesAutoloadGenerationRoot'));
}
public function testFilesAutoloadGenerationRemoveExtraEntitiesFromAutoloadFiles(): void
{
$autoloadPackage = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$autoloadPackage->setAutoload(['files' => ['root.php']]);
$autoloadPackage->setIncludePaths(['/lib', '/src']);
$notAutoloadPackage = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$requires = [
'a/a' => new Link('a', 'a/a', new MatchAllConstraint()),
'b/b' => new Link('a', 'b/b', new MatchAllConstraint()),
'c/c' => new Link('a', 'c/c', new MatchAllConstraint()),
2022-08-17 12:20:07 +00:00
];
$autoloadPackage->setRequires($requires);
$notAutoloadPackage->setRequires($requires);
2022-08-17 12:20:07 +00:00
$autoloadPackages = [];
$autoloadPackages[] = $a = new Package('a/a', '1.0', '1.0');
$autoloadPackages[] = $b = new Package('b/b', '1.0', '1.0');
$autoloadPackages[] = $c = new Package('c/c', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$a->setAutoload(['files' => ['test.php']]);
$a->setIncludePaths(['lib1', 'src1']);
$b->setAutoload(['files' => ['test2.php']]);
$b->setIncludePaths(['lib2']);
$c->setAutoload(['files' => ['test3.php', 'foo/bar/test4.php']]);
$c->setIncludePaths(['lib3']);
$c->setTargetDir('foo/bar');
2022-08-17 12:20:07 +00:00
$notAutoloadPackages = [];
$notAutoloadPackages[] = $a = new Package('a/a', '1.0', '1.0');
$notAutoloadPackages[] = $b = new Package('b/b', '1.0', '1.0');
$notAutoloadPackages[] = $c = new Package('c/c', '1.0', '1.0');
$this->repository->expects($this->exactly(3))
->method('getCanonicalPackages')
->willReturnOnConsecutiveCalls(
$autoloadPackages,
$notAutoloadPackages,
$notAutoloadPackages
);
$this->fs->ensureDirectoryExists($this->vendorDir.'/a/a');
$this->fs->ensureDirectoryExists($this->vendorDir.'/b/b');
$this->fs->ensureDirectoryExists($this->vendorDir.'/c/c/foo/bar');
file_put_contents($this->vendorDir.'/a/a/test.php', '<?php function testFilesAutoloadGeneration1() {}');
file_put_contents($this->vendorDir.'/b/b/test2.php', '<?php function testFilesAutoloadGeneration2() {}');
file_put_contents($this->vendorDir.'/c/c/foo/bar/test3.php', '<?php function testFilesAutoloadGeneration3() {}');
file_put_contents($this->vendorDir.'/c/c/foo/bar/test4.php', '<?php function testFilesAutoloadGeneration4() {}');
file_put_contents($this->workingDir.'/root.php', '<?php function testFilesAutoloadGenerationRoot() {}');
$this->generator->dump($this->config, $this->repository, $autoloadPackage, $this->im, 'composer', false, 'FilesAutoload');
2020-02-07 03:18:45 +00:00
$this->assertFileContentEquals(__DIR__.'/Fixtures/autoload_functions.php', $this->vendorDir.'/autoload.php');
$this->assertFileContentEquals(__DIR__.'/Fixtures/autoload_real_functions_with_include_paths.php', $this->vendorDir.'/composer/autoload_real.php');
$this->assertFileContentEquals(__DIR__.'/Fixtures/autoload_static_functions_with_include_paths.php', $this->vendorDir.'/composer/autoload_static.php');
$this->assertFileContentEquals(__DIR__.'/Fixtures/autoload_files_functions.php', $this->vendorDir.'/composer/autoload_files.php');
$this->assertFileContentEquals(__DIR__.'/Fixtures/include_paths_functions.php', $this->vendorDir.'/composer/include_paths.php');
$this->generator->dump($this->config, $this->repository, $autoloadPackage, $this->im, 'composer', false, 'FilesAutoload');
2020-02-07 03:18:45 +00:00
$this->assertFileContentEquals(__DIR__.'/Fixtures/autoload_functions.php', $this->vendorDir.'/autoload.php');
$this->assertFileContentEquals(__DIR__.'/Fixtures/autoload_real_functions_with_include_paths.php', $this->vendorDir.'/composer/autoload_real.php');
$this->assertFileContentEquals(__DIR__.'/Fixtures/autoload_files_functions_with_removed_extra.php', $this->vendorDir.'/composer/autoload_files.php');
$this->assertFileContentEquals(__DIR__.'/Fixtures/include_paths_functions_with_removed_extra.php', $this->vendorDir.'/composer/include_paths.php');
$this->generator->dump($this->config, $this->repository, $notAutoloadPackage, $this->im, 'composer', false, 'FilesAutoload');
2020-02-07 03:18:45 +00:00
$this->assertFileContentEquals(__DIR__.'/Fixtures/autoload_functions.php', $this->vendorDir.'/autoload.php');
$this->assertFileContentEquals(__DIR__.'/Fixtures/autoload_real_functions_with_removed_include_paths_and_autolad_files.php', $this->vendorDir.'/composer/autoload_real.php');
$this->assertFileContentEquals(__DIR__.'/Fixtures/autoload_static_functions_with_removed_include_paths_and_autolad_files.php', $this->vendorDir.'/composer/autoload_static.php');
2020-09-11 09:27:26 +00:00
$this->assertFileDoesNotExist($this->vendorDir.'/composer/autoload_files.php');
$this->assertFileDoesNotExist($this->vendorDir.'/composer/include_paths.php');
}
public function testFilesAutoloadOrderByDependencies(): void
{
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$package->setAutoload(['files' => ['root2.php']]);
$package->setRequires([
'z/foo' => new Link('a', 'z/foo', new MatchAllConstraint()),
'b/bar' => new Link('a', 'b/bar', new MatchAllConstraint()),
'd/d' => new Link('a', 'd/d', new MatchAllConstraint()),
'e/e' => new Link('a', 'e/e', new MatchAllConstraint()),
2022-08-17 12:20:07 +00:00
]);
2022-08-17 12:20:07 +00:00
$packages = [];
$packages[] = $z = new Package('z/foo', '1.0', '1.0');
$packages[] = $b = new Package('b/bar', '1.0', '1.0');
$packages[] = $d = new Package('d/d', '1.0', '1.0');
$packages[] = $c = new Package('c/lorem', '1.0', '1.0');
$packages[] = $e = new Package('e/e', '1.0', '1.0');
// expected order:
// c requires nothing
// d requires c
// b requires c & d
// e requires c
// z requires c
// (b, e, z ordered alphabetically)
2022-08-17 12:20:07 +00:00
$z->setAutoload(['files' => ['testA.php']]);
$z->setRequires(['c/lorem' => new Link('z/foo', 'c/lorem', new MatchAllConstraint())]);
2022-08-17 12:20:07 +00:00
$b->setAutoload(['files' => ['testB.php']]);
$b->setRequires(['c/lorem' => new Link('b/bar', 'c/lorem', new MatchAllConstraint()), 'd/d' => new Link('b/bar', 'd/d', new MatchAllConstraint())]);
2022-08-17 12:20:07 +00:00
$c->setAutoload(['files' => ['testC.php']]);
2022-08-17 12:20:07 +00:00
$d->setAutoload(['files' => ['testD.php']]);
$d->setRequires(['c/lorem' => new Link('d/d', 'c/lorem', new MatchAllConstraint())]);
2022-08-17 12:20:07 +00:00
$e->setAutoload(['files' => ['testE.php']]);
$e->setRequires(['c/lorem' => new Link('e/e', 'c/lorem', new MatchAllConstraint())]);
$this->repository->expects($this->once())
->method('getCanonicalPackages')
->will($this->returnValue($packages));
$this->fs->ensureDirectoryExists($this->vendorDir . '/z/foo');
$this->fs->ensureDirectoryExists($this->vendorDir . '/b/bar');
$this->fs->ensureDirectoryExists($this->vendorDir . '/c/lorem');
$this->fs->ensureDirectoryExists($this->vendorDir . '/d/d');
$this->fs->ensureDirectoryExists($this->vendorDir . '/e/e');
file_put_contents($this->vendorDir . '/z/foo/testA.php', '<?php function testFilesAutoloadOrderByDependency1() {}');
file_put_contents($this->vendorDir . '/b/bar/testB.php', '<?php function testFilesAutoloadOrderByDependency2() {}');
file_put_contents($this->vendorDir . '/c/lorem/testC.php', '<?php function testFilesAutoloadOrderByDependency3() {}');
file_put_contents($this->vendorDir . '/d/d/testD.php', '<?php function testFilesAutoloadOrderByDependency4() {}');
file_put_contents($this->vendorDir . '/e/e/testE.php', '<?php function testFilesAutoloadOrderByDependency5() {}');
file_put_contents($this->workingDir . '/root2.php', '<?php function testFilesAutoloadOrderByDependencyRoot() {}');
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', false, 'FilesAutoloadOrder');
2020-02-07 03:18:45 +00:00
$this->assertFileContentEquals(__DIR__ . '/Fixtures/autoload_functions_by_dependency.php', $this->vendorDir . '/autoload.php');
$this->assertFileContentEquals(__DIR__ . '/Fixtures/autoload_real_files_by_dependency.php', $this->vendorDir . '/composer/autoload_real.php');
$this->assertFileContentEquals(__DIR__ . '/Fixtures/autoload_static_files_by_dependency.php', $this->vendorDir . '/composer/autoload_static.php');
$loader = require $this->vendorDir . '/autoload.php';
$loader->unregister();
$this->assertTrue(function_exists('testFilesAutoloadOrderByDependency1'));
$this->assertTrue(function_exists('testFilesAutoloadOrderByDependency2'));
$this->assertTrue(function_exists('testFilesAutoloadOrderByDependency3'));
$this->assertTrue(function_exists('testFilesAutoloadOrderByDependency4'));
$this->assertTrue(function_exists('testFilesAutoloadOrderByDependency5'));
$this->assertTrue(function_exists('testFilesAutoloadOrderByDependencyRoot'));
}
/**
* Test that PSR-0 and PSR-4 mappings are processed in the correct order for
* autoloading and for classmap generation:
* - The main package has priority over other packages.
* - Longer namespaces have priority over shorter namespaces.
*/
public function testOverrideVendorsAutoloading(): void
{
$rootPackage = new RootPackage('root/z', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$rootPackage->setAutoload([
'psr-0' => ['A\\B' => $this->workingDir.'/lib'],
'classmap' => [$this->workingDir.'/src'],
]);
$rootPackage->setRequires([
'a/a' => new Link('z', 'a/a', new MatchAllConstraint()),
'b/b' => new Link('z', 'b/b', new MatchAllConstraint()),
2022-08-17 12:20:07 +00:00
]);
2022-08-17 12:20:07 +00:00
$packages = [];
$packages[] = $a = new Package('a/a', '1.0', '1.0');
$packages[] = $b = new Package('b/b', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$a->setAutoload([
'psr-0' => ['A' => 'src/', 'A\\B' => 'lib/'],
'classmap' => ['classmap'],
]);
$b->setAutoload([
'psr-0' => ['B\\Sub\\Name' => 'src/'],
]);
$this->repository->expects($this->once())
->method('getCanonicalPackages')
->will($this->returnValue($packages));
$this->fs->ensureDirectoryExists($this->workingDir.'/lib/A/B');
$this->fs->ensureDirectoryExists($this->workingDir.'/src/');
$this->fs->ensureDirectoryExists($this->vendorDir.'/composer');
$this->fs->ensureDirectoryExists($this->vendorDir.'/a/a/classmap');
$this->fs->ensureDirectoryExists($this->vendorDir.'/a/a/src');
$this->fs->ensureDirectoryExists($this->vendorDir.'/a/a/lib/A/B');
$this->fs->ensureDirectoryExists($this->vendorDir.'/b/b/src');
// Define the classes A\B\C and Foo\Bar in the main package.
file_put_contents($this->workingDir.'/lib/A/B/C.php', '<?php namespace A\\B; class C {}');
file_put_contents($this->workingDir.'/src/classes.php', '<?php namespace Foo; class Bar {}');
// Define the same two classes in the package a/a.
file_put_contents($this->vendorDir.'/a/a/lib/A/B/C.php', '<?php namespace A\\B; class C {}');
file_put_contents($this->vendorDir.'/a/a/classmap/classes.php', '<?php namespace Foo; class Bar {}');
$expectedNamespace = <<<EOF
<?php
// autoload_namespaces.php @generated by Composer
2020-11-06 23:08:03 +00:00
\$vendorDir = dirname(__DIR__);
\$baseDir = dirname(\$vendorDir);
return array(
'B\\\\Sub\\\\Name' => array(\$vendorDir . '/b/b/src'),
2013-03-14 09:23:35 +00:00
'A\\\\B' => array(\$baseDir . '/lib', \$vendorDir . '/a/a/lib'),
'A' => array(\$vendorDir . '/a/a/src'),
);
EOF;
// autoload_psr4.php is expected to be empty in this example.
$expectedPsr4 = <<<EOF
<?php
// autoload_psr4.php @generated by Composer
2020-11-06 23:08:03 +00:00
\$vendorDir = dirname(__DIR__);
\$baseDir = dirname(\$vendorDir);
return array(
);
EOF;
$expectedClassmap = <<<EOF
<?php
// autoload_classmap.php @generated by Composer
2020-11-06 23:08:03 +00:00
\$vendorDir = dirname(__DIR__);
\$baseDir = dirname(\$vendorDir);
return array(
'A\\\\B\\\\C' => \$baseDir . '/lib/A/B/C.php',
'Composer\\\\InstalledVersions' => \$vendorDir . '/composer/InstalledVersions.php',
'Foo\\\\Bar' => \$baseDir . '/src/classes.php',
);
EOF;
$this->generator->dump($this->config, $this->repository, $rootPackage, $this->im, 'composer', true, '_9');
2017-12-03 04:41:58 +00:00
$this->assertStringEqualsFile($this->vendorDir.'/composer/autoload_namespaces.php', $expectedNamespace);
$this->assertStringEqualsFile($this->vendorDir.'/composer/autoload_psr4.php', $expectedPsr4);
$this->assertStringEqualsFile($this->vendorDir.'/composer/autoload_classmap.php', $expectedClassmap);
}
public function testIncludePathFileGeneration(): void
2012-04-04 13:15:37 +00:00
{
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$packages = [];
2012-04-04 13:15:37 +00:00
$a = new Package("a/a", "1.0", "1.0");
2022-08-17 12:20:07 +00:00
$a->setIncludePaths(["lib/"]);
2012-04-04 13:15:37 +00:00
$b = new Package("b/b", "1.0", "1.0");
2022-08-17 12:20:07 +00:00
$b->setIncludePaths(["library"]);
2012-04-04 13:15:37 +00:00
$c = new Package("c", "1.0", "1.0");
2022-08-17 12:20:07 +00:00
$c->setIncludePaths(["library"]);
2012-04-04 13:15:37 +00:00
$packages[] = $a;
$packages[] = $b;
$packages[] = $c;
2012-04-04 13:15:37 +00:00
$this->repository->expects($this->once())
->method("getCanonicalPackages")
2012-04-04 13:15:37 +00:00
->will($this->returnValue($packages));
$this->fs->ensureDirectoryExists($this->vendorDir.'/composer');
2012-04-04 13:15:37 +00:00
2012-08-14 18:28:49 +00:00
$this->generator->dump($this->config, $this->repository, $package, $this->im, "composer", false, '_10');
2012-04-04 13:15:37 +00:00
2020-02-07 03:18:45 +00:00
$this->assertFileContentEquals(__DIR__.'/Fixtures/include_paths.php', $this->vendorDir.'/composer/include_paths.php');
2012-04-04 13:15:37 +00:00
$this->assertEquals(
2022-08-17 12:20:07 +00:00
[
$this->vendorDir."/a/a/lib",
$this->vendorDir."/b/b/library",
$this->vendorDir."/c/library",
2022-08-17 12:20:07 +00:00
],
require $this->vendorDir."/composer/include_paths.php"
2012-04-04 13:15:37 +00:00
);
}
public function testIncludePathsArePrependedInAutoloadFile(): void
2012-04-04 13:15:37 +00:00
{
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$packages = [];
2012-04-04 13:15:37 +00:00
$a = new Package("a/a", "1.0", "1.0");
2022-08-17 12:20:07 +00:00
$a->setIncludePaths(["lib/"]);
2012-04-04 13:15:37 +00:00
$packages[] = $a;
$this->repository->expects($this->once())
->method("getCanonicalPackages")
2012-04-04 13:15:37 +00:00
->will($this->returnValue($packages));
mkdir($this->vendorDir."/composer", 0777, true);
2012-04-04 13:15:37 +00:00
2012-08-14 18:28:49 +00:00
$this->generator->dump($this->config, $this->repository, $package, $this->im, "composer", false, '_11');
2012-04-04 13:15:37 +00:00
$oldIncludePath = get_include_path();
$loader = require $this->vendorDir."/autoload.php";
$loader->unregister();
2012-04-04 13:15:37 +00:00
$this->assertEquals(
$this->vendorDir."/a/a/lib".PATH_SEPARATOR.$oldIncludePath,
2012-04-04 13:15:37 +00:00
get_include_path()
);
set_include_path($oldIncludePath);
}
public function testIncludePathsInRootPackage(): void
{
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$package->setIncludePaths(['/lib', '/src']);
2022-08-17 12:20:07 +00:00
$packages = [$a = new Package("a/a", "1.0", "1.0")];
$a->setIncludePaths(["lib/"]);
$this->repository->expects($this->once())
->method("getCanonicalPackages")
->will($this->returnValue($packages));
mkdir($this->vendorDir."/composer", 0777, true);
$this->generator->dump($this->config, $this->repository, $package, $this->im, "composer", false, '_12');
$oldIncludePath = get_include_path();
$loader = require $this->vendorDir."/autoload.php";
$loader->unregister();
$this->assertEquals(
$this->workingDir."/lib".PATH_SEPARATOR.$this->workingDir."/src".PATH_SEPARATOR.$this->vendorDir."/a/a/lib".PATH_SEPARATOR.$oldIncludePath,
get_include_path()
);
set_include_path($oldIncludePath);
}
public function testIncludePathFileWithoutPathsIsSkipped(): void
2012-04-04 13:15:37 +00:00
{
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$packages = [];
2012-04-04 13:15:37 +00:00
$a = new Package("a/a", "1.0", "1.0");
2012-04-04 13:15:37 +00:00
$packages[] = $a;
$this->repository->expects($this->once())
->method("getCanonicalPackages")
2012-04-04 13:15:37 +00:00
->will($this->returnValue($packages));
mkdir($this->vendorDir."/composer", 0777, true);
2012-04-04 13:15:37 +00:00
2012-08-14 18:28:49 +00:00
$this->generator->dump($this->config, $this->repository, $package, $this->im, "composer", false, '_12');
2012-04-04 13:15:37 +00:00
2020-09-11 09:27:26 +00:00
$this->assertFileDoesNotExist($this->vendorDir."/composer/include_paths.php");
2012-04-04 13:15:37 +00:00
}
public function testPreAndPostEventsAreDispatchedDuringAutoloadDump(): void
2013-01-06 19:34:52 +00:00
{
$this->eventDispatcher
->expects($this->exactly(2))
->method('dispatchScript')
->withConsecutive(
[ScriptEvents::PRE_AUTOLOAD_DUMP, false],
[ScriptEvents::POST_AUTOLOAD_DUMP, false]
);
2013-01-06 19:34:52 +00:00
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$package->setAutoload(['psr-0' => ['Prefix' => 'foo/bar/non/existing/']]);
2013-01-06 19:34:52 +00:00
$this->repository->expects($this->once())
->method('getCanonicalPackages')
2022-08-17 12:20:07 +00:00
->will($this->returnValue([]));
2013-01-06 19:34:52 +00:00
$this->generator->setRunScripts(true);
2013-01-06 19:34:52 +00:00
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', true, '_8');
}
public function testUseGlobalIncludePath(): void
2013-02-04 08:12:41 +00:00
{
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$package->setAutoload([
'psr-0' => ['Main\\Foo' => '', 'Main\\Bar' => ''],
]);
2013-02-04 08:12:41 +00:00
$package->setTargetDir('Main/Foo/');
$this->repository->expects($this->once())
->method('getCanonicalPackages')
2022-08-17 12:20:07 +00:00
->will($this->returnValue([]));
$this->configValueMap['use-include-path'] = true;
2013-02-04 08:12:41 +00:00
$this->fs->ensureDirectoryExists($this->vendorDir.'/a');
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', false, 'IncludePath');
2020-02-07 03:18:45 +00:00
$this->assertFileContentEquals(__DIR__.'/Fixtures/autoload_real_include_path.php', $this->vendorDir.'/composer/autoload_real.php');
$this->assertFileContentEquals(__DIR__.'/Fixtures/autoload_static_include_path.php', $this->vendorDir.'/composer/autoload_static.php');
2013-02-04 08:12:41 +00:00
}
2012-04-04 13:15:37 +00:00
public function testVendorDirExcludedFromWorkingDir(): void
{
$workingDir = $this->vendorDir.'/working-dir';
$vendorDir = $workingDir.'/../vendor';
$this->fs->ensureDirectoryExists($workingDir);
chdir($workingDir);
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$package->setAutoload([
'psr-0' => ['Foo' => 'src'],
'psr-4' => ['Acme\Foo\\' => 'src-psr4'],
'classmap' => ['classmap'],
'files' => ['test.php'],
]);
$package->setRequires([
'b/b' => new Link('a', 'b/b', new MatchAllConstraint()),
2022-08-17 12:20:07 +00:00
]);
$vendorPackage = new Package('b/b', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$vendorPackage->setAutoload([
'psr-0' => ['Bar' => 'lib'],
'psr-4' => ['Acme\Bar\\' => 'lib-psr4'],
'classmap' => ['classmaps'],
'files' => ['bootstrap.php'],
]);
$this->repository->expects($this->once())
->method('getCanonicalPackages')
2022-08-17 12:20:07 +00:00
->will($this->returnValue([$vendorPackage]));
$im = $this->getMockBuilder('Composer\Installer\InstallationManager')
->disableOriginalConstructor()
->getMock();
$im->expects($this->any())
->method('getInstallPath')
2022-08-17 12:20:07 +00:00
->will($this->returnCallback(static function ($package) use ($vendorDir): string {
$targetDir = $package->getTargetDir();
2013-06-13 11:28:24 +00:00
return $vendorDir.'/'.$package->getName() . ($targetDir ? '/'.$targetDir : '');
}));
$this->fs->ensureDirectoryExists($workingDir.'/src/Foo');
$this->fs->ensureDirectoryExists($workingDir.'/classmap');
$this->fs->ensureDirectoryExists($vendorDir.'/composer');
$this->fs->ensureDirectoryExists($vendorDir.'/b/b/lib/Bar');
$this->fs->ensureDirectoryExists($vendorDir.'/b/b/classmaps');
file_put_contents($workingDir.'/src/Foo/Bar.php', '<?php namespace Foo; class Bar {}');
file_put_contents($workingDir.'/classmap/classes.php', '<?php namespace Foo; class Foo {}');
file_put_contents($workingDir.'/test.php', '<?php class Foo {}');
file_put_contents($vendorDir.'/b/b/lib/Bar/Foo.php', '<?php namespace Bar; class Foo {}');
file_put_contents($vendorDir.'/b/b/classmaps/classes.php', '<?php namespace Bar; class Bar {}');
file_put_contents($vendorDir.'/b/b/bootstrap.php', '<?php class Bar {}');
$oldVendorDir = $this->vendorDir;
$this->vendorDir = $vendorDir;
$this->generator->dump($this->config, $this->repository, $package, $im, 'composer', true, '_13');
$this->vendorDir = $oldVendorDir;
$expectedNamespace = <<<'EOF'
<?php
// autoload_namespaces.php @generated by Composer
2020-11-06 23:08:03 +00:00
$vendorDir = dirname(__DIR__);
$baseDir = dirname($vendorDir).'/working-dir';
return array(
'Foo' => array($baseDir . '/src'),
'Bar' => array($vendorDir . '/b/b/lib'),
);
EOF;
$expectedPsr4 = <<<'EOF'
<?php
// autoload_psr4.php @generated by Composer
2020-11-06 23:08:03 +00:00
$vendorDir = dirname(__DIR__);
$baseDir = dirname($vendorDir).'/working-dir';
return array(
'Acme\\Foo\\' => array($baseDir . '/src-psr4'),
'Acme\\Bar\\' => array($vendorDir . '/b/b/lib-psr4'),
);
EOF;
$expectedClassmap = <<<'EOF'
<?php
// autoload_classmap.php @generated by Composer
2020-11-06 23:08:03 +00:00
$vendorDir = dirname(__DIR__);
$baseDir = dirname($vendorDir).'/working-dir';
return array(
'Bar\\Bar' => $vendorDir . '/b/b/classmaps/classes.php',
'Bar\\Foo' => $vendorDir . '/b/b/lib/Bar/Foo.php',
'Composer\\InstalledVersions' => $vendorDir . '/composer/InstalledVersions.php',
'Foo\\Bar' => $baseDir . '/src/Foo/Bar.php',
'Foo\\Foo' => $baseDir . '/classmap/classes.php',
);
EOF;
2017-12-03 04:41:58 +00:00
$this->assertStringEqualsFile($vendorDir.'/composer/autoload_namespaces.php', $expectedNamespace);
$this->assertStringEqualsFile($vendorDir.'/composer/autoload_psr4.php', $expectedPsr4);
$this->assertStringEqualsFile($vendorDir.'/composer/autoload_classmap.php', $expectedClassmap);
$this->assertStringContainsString("\$vendorDir . '/b/b/bootstrap.php',\n", (string) file_get_contents($vendorDir.'/composer/autoload_files.php'));
$this->assertStringContainsString("\$baseDir . '/test.php',\n", (string) file_get_contents($vendorDir.'/composer/autoload_files.php'));
}
public function testUpLevelRelativePaths(): void
{
$workingDir = $this->workingDir.'/working-dir';
mkdir($workingDir, 0777, true);
chdir($workingDir);
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$package->setAutoload([
'psr-0' => ['Foo' => '../path/../src'],
'psr-4' => ['Acme\Foo\\' => '../path/../src-psr4'],
'classmap' => ['../classmap', '../classmap2/subdir', 'classmap3', 'classmap4'],
'files' => ['../test.php'],
'exclude-from-classmap' => ['./../classmap/excluded', '../classmap2', 'classmap3/classes.php', 'classmap4/*/classes.php'],
]);
$this->repository->expects($this->once())
->method('getCanonicalPackages')
2022-08-17 12:20:07 +00:00
->will($this->returnValue([]));
$this->fs->ensureDirectoryExists($this->workingDir.'/src/Foo');
$this->fs->ensureDirectoryExists($this->workingDir.'/classmap/excluded');
$this->fs->ensureDirectoryExists($this->workingDir.'/classmap2/subdir');
$this->fs->ensureDirectoryExists($this->workingDir.'/working-dir/classmap3');
$this->fs->ensureDirectoryExists($this->workingDir.'/working-dir/classmap4/foo/');
file_put_contents($this->workingDir.'/src/Foo/Bar.php', '<?php namespace Foo; class Bar {}');
file_put_contents($this->workingDir.'/classmap/classes.php', '<?php namespace Foo; class Foo {}');
file_put_contents($this->workingDir.'/classmap/excluded/classes.php', '<?php namespace Foo; class Boo {}');
file_put_contents($this->workingDir.'/classmap2/subdir/classes.php', '<?php namespace Foo; class Boo2 {}');
file_put_contents($this->workingDir.'/working-dir/classmap3/classes.php', '<?php namespace Foo; class Boo3 {}');
file_put_contents($this->workingDir.'/working-dir/classmap4/foo/classes.php', '<?php namespace Foo; class Boo4 {}');
file_put_contents($this->workingDir.'/test.php', '<?php class Foo {}');
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', true, '_14');
$expectedNamespace = <<<'EOF'
<?php
// autoload_namespaces.php @generated by Composer
2020-11-06 23:08:03 +00:00
$vendorDir = dirname(__DIR__);
$baseDir = dirname($vendorDir).'/working-dir';
return array(
'Foo' => array($baseDir . '/../src'),
);
EOF;
$expectedPsr4 = <<<'EOF'
<?php
// autoload_psr4.php @generated by Composer
2020-11-06 23:08:03 +00:00
$vendorDir = dirname(__DIR__);
$baseDir = dirname($vendorDir).'/working-dir';
return array(
'Acme\\Foo\\' => array($baseDir . '/../src-psr4'),
);
EOF;
$expectedClassmap = <<<'EOF'
<?php
// autoload_classmap.php @generated by Composer
2020-11-06 23:08:03 +00:00
$vendorDir = dirname(__DIR__);
$baseDir = dirname($vendorDir).'/working-dir';
return array(
'Composer\\InstalledVersions' => $vendorDir . '/composer/InstalledVersions.php',
'Foo\\Bar' => $baseDir . '/../src/Foo/Bar.php',
'Foo\\Foo' => $baseDir . '/../classmap/classes.php',
);
EOF;
2017-12-03 04:41:58 +00:00
$this->assertStringEqualsFile($this->vendorDir.'/composer/autoload_namespaces.php', $expectedNamespace);
$this->assertStringEqualsFile($this->vendorDir.'/composer/autoload_psr4.php', $expectedPsr4);
$this->assertStringEqualsFile($this->vendorDir.'/composer/autoload_classmap.php', $expectedClassmap);
$this->assertStringContainsString("\$baseDir . '/../test.php',\n", (string) file_get_contents($this->vendorDir.'/composer/autoload_files.php'));
}
2022-04-01 20:10:24 +00:00
public function testAutoloadRulesInPackageThatDoesNotExistOnDisk(): void
{
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$package->setRequires([
'dep/a' => new Link('root/a', 'dep/a', new MatchAllConstraint(), 'requires'),
2022-08-17 12:20:07 +00:00
]);
$dep = new CompletePackage('dep/a', '1.0', '1.0');
$this->repository->expects($this->any())
->method('getCanonicalPackages')
2022-08-17 12:20:07 +00:00
->will($this->returnValue([$dep]));
2022-08-17 12:20:07 +00:00
$dep->setAutoload([
'psr-0' => ['Foo' => './src'],
]);
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', true, '_19');
$expectedNamespace = <<<'EOF'
<?php
// autoload_namespaces.php @generated by Composer
2022-04-01 20:10:24 +00:00
$vendorDir = dirname(__DIR__);
$baseDir = dirname($vendorDir);
return array(
'Foo' => array($vendorDir . '/dep/a/src'),
);
EOF;
$this->assertStringEqualsFile($this->vendorDir.'/composer/autoload_namespaces.php', $expectedNamespace);
2022-08-17 12:20:07 +00:00
$dep->setAutoload([
'psr-4' => ['Acme\Foo\\' => './src-psr4'],
]);
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', true, '_19');
$expectedPsr4 = <<<'EOF'
<?php
// autoload_psr4.php @generated by Composer
2022-04-01 20:10:24 +00:00
$vendorDir = dirname(__DIR__);
$baseDir = dirname($vendorDir);
return array(
'Acme\\Foo\\' => array($vendorDir . '/dep/a/src-psr4'),
);
EOF;
$this->assertStringEqualsFile($this->vendorDir.'/composer/autoload_psr4.php', $expectedPsr4);
2022-08-17 12:20:07 +00:00
$dep->setAutoload([
'classmap' => ['classmap'],
]);
try {
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', true, '_19');
} catch (\RuntimeException $e) {
$this->assertSame('Could not scan for classes inside "'.$this->vendorDir.'/dep/a/classmap" which does not appear to be a file nor a folder', $e->getMessage());
}
2022-08-17 12:20:07 +00:00
$dep->setAutoload([
'files' => ['./test.php'],
]);
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', true, '_19');
$this->assertStringContainsString("\$vendorDir . '/dep/a/test.php',\n", (string) file_get_contents($this->vendorDir.'/composer/autoload_files.php'));
2022-08-17 12:20:07 +00:00
$package->setAutoload([
'exclude-from-classmap' => ['../excludedroot', 'root/excl'],
]);
$dep->setAutoload([
'exclude-from-classmap' => ['../../excluded', 'foo/bar'],
]);
$map = $this->generator->buildPackageMap($this->im, $package, [$dep]);
$parsed = $this->generator->parseAutoloads($map, $package);
2022-08-17 12:20:07 +00:00
$this->assertSame([
2022-04-02 10:58:29 +00:00
preg_quote(strtr((string) realpath(dirname($this->workingDir)), '\\', '/')).'/excludedroot($|/)',
2022-08-17 12:20:07 +00:00
preg_quote(strtr((string) realpath($this->workingDir), '\\', '/')).'/root/excl($|/)',
], $parsed['exclude-from-classmap']);
}
public function testEmptyPaths(): void
{
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$package->setAutoload([
'psr-0' => ['Foo' => ''],
'psr-4' => ['Acme\Foo\\' => ''],
'classmap' => [''],
]);
$this->repository->expects($this->once())
->method('getCanonicalPackages')
2022-08-17 12:20:07 +00:00
->will($this->returnValue([]));
$this->fs->ensureDirectoryExists($this->workingDir.'/Foo');
file_put_contents($this->workingDir.'/Foo/Bar.php', '<?php namespace Foo; class Bar {}');
file_put_contents($this->workingDir.'/class.php', '<?php namespace Classmap; class Foo {}');
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', true, '_15');
$expectedNamespace = <<<'EOF'
<?php
// autoload_namespaces.php @generated by Composer
2020-11-06 23:08:03 +00:00
$vendorDir = dirname(__DIR__);
$baseDir = dirname($vendorDir);
return array(
'Foo' => array($baseDir . '/'),
);
EOF;
$expectedPsr4 = <<<'EOF'
<?php
// autoload_psr4.php @generated by Composer
2020-11-06 23:08:03 +00:00
$vendorDir = dirname(__DIR__);
$baseDir = dirname($vendorDir);
return array(
'Acme\\Foo\\' => array($baseDir . '/'),
);
EOF;
$expectedClassmap = <<<'EOF'
<?php
// autoload_classmap.php @generated by Composer
2020-11-06 23:08:03 +00:00
$vendorDir = dirname(__DIR__);
$baseDir = dirname($vendorDir);
return array(
'Classmap\\Foo' => $baseDir . '/class.php',
'Composer\\InstalledVersions' => $vendorDir . '/composer/InstalledVersions.php',
'Foo\\Bar' => $baseDir . '/Foo/Bar.php',
);
EOF;
2017-12-03 04:41:58 +00:00
$this->assertStringEqualsFile($this->vendorDir.'/composer/autoload_namespaces.php', $expectedNamespace);
$this->assertStringEqualsFile($this->vendorDir.'/composer/autoload_psr4.php', $expectedPsr4);
$this->assertStringEqualsFile($this->vendorDir.'/composer/autoload_classmap.php', $expectedClassmap);
}
public function testVendorSubstringPath(): void
2013-09-26 12:34:41 +00:00
{
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$package->setAutoload([
'psr-0' => ['Foo' => 'composer-test-autoload-src/src'],
'psr-4' => ['Acme\Foo\\' => 'composer-test-autoload-src/src-psr4'],
]);
2013-09-26 12:34:41 +00:00
$this->repository->expects($this->once())
->method('getCanonicalPackages')
2022-08-17 12:20:07 +00:00
->will($this->returnValue([]));
2013-09-26 12:34:41 +00:00
$this->fs->ensureDirectoryExists($this->vendorDir.'/a');
$expectedNamespace = <<<'EOF'
<?php
// autoload_namespaces.php @generated by Composer
2020-11-06 23:08:03 +00:00
$vendorDir = dirname(__DIR__);
2013-09-26 12:34:41 +00:00
$baseDir = dirname($vendorDir);
return array(
'Foo' => array($baseDir . '/composer-test-autoload-src/src'),
);
EOF;
$expectedPsr4 = <<<'EOF'
<?php
// autoload_psr4.php @generated by Composer
2020-11-06 23:08:03 +00:00
$vendorDir = dirname(__DIR__);
$baseDir = dirname($vendorDir);
return array(
'Acme\\Foo\\' => array($baseDir . '/composer-test-autoload-src/src-psr4'),
);
2013-09-26 12:34:41 +00:00
EOF;
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', false, 'VendorSubstring');
2017-12-03 04:41:58 +00:00
$this->assertStringEqualsFile($this->vendorDir.'/composer/autoload_namespaces.php', $expectedNamespace);
$this->assertStringEqualsFile($this->vendorDir.'/composer/autoload_psr4.php', $expectedPsr4);
2013-09-26 12:34:41 +00:00
}
public function testExcludeFromClassmap(): void
{
$package = new RootPackage('root/a', '1.0', '1.0');
2022-08-17 12:20:07 +00:00
$package->setAutoload([
'psr-0' => [
'Main' => 'src/',
2022-08-17 12:20:07 +00:00
'Lala' => ['src/', 'lib/'],
],
'psr-4' => [
'Acme\Fruit\\' => 'src-fruit/',
2022-08-17 12:20:07 +00:00
'Acme\Cake\\' => ['src-cake/', 'lib-cake/'],
],
'classmap' => ['composersrc/'],
'exclude-from-classmap' => [
'/composersrc/foo/bar/',
'/composersrc/excludedTests/',
'/composersrc/ClassToExclude.php',
'/composersrc/*/excluded/excsubpath',
'**/excsubpath',
'composers', // should _not_ cause exclusion of /composersrc/**, as it is equivalent to /composers/**
'/src-ca/', // should _not_ cause exclusion of /src-cake/**, as it is equivalent to /src-ca/**
2022-08-17 12:20:07 +00:00
],
]);
$this->repository->expects($this->once())
->method('getCanonicalPackages')
2022-08-17 12:20:07 +00:00
->will($this->returnValue([]));
$this->fs->ensureDirectoryExists($this->workingDir.'/composer');
$this->fs->ensureDirectoryExists($this->workingDir.'/src/Lala/Test');
$this->fs->ensureDirectoryExists($this->workingDir.'/lib');
file_put_contents($this->workingDir.'/src/Lala/ClassMapMain.php', '<?php namespace Lala; class ClassMapMain {}');
file_put_contents($this->workingDir.'/src/Lala/Test/ClassMapMainTest.php', '<?php namespace Lala\Test; class ClassMapMainTest {}');
$this->fs->ensureDirectoryExists($this->workingDir.'/src-fruit');
$this->fs->ensureDirectoryExists($this->workingDir.'/src-cake');
$this->fs->ensureDirectoryExists($this->workingDir.'/lib-cake');
file_put_contents($this->workingDir.'/src-cake/ClassMapBar.php', '<?php namespace Acme\Cake; class ClassMapBar {}');
$this->fs->ensureDirectoryExists($this->workingDir.'/composersrc');
$this->fs->ensureDirectoryExists($this->workingDir.'/composersrc/tests');
file_put_contents($this->workingDir.'/composersrc/foo.php', '<?php class ClassMapFoo {}');
// these classes should not be found in the classmap
$this->fs->ensureDirectoryExists($this->workingDir.'/composersrc/excludedTests');
file_put_contents($this->workingDir.'/composersrc/excludedTests/bar.php', '<?php class ClassExcludeMapFoo {}');
file_put_contents($this->workingDir.'/composersrc/ClassToExclude.php', '<?php class ClassClassToExclude {}');
$this->fs->ensureDirectoryExists($this->workingDir.'/composersrc/long/excluded/excsubpath');
file_put_contents($this->workingDir.'/composersrc/long/excluded/excsubpath/foo.php', '<?php class ClassExcludeMapFoo2 {}');
file_put_contents($this->workingDir.'/composersrc/long/excluded/excsubpath/bar.php', '<?php class ClassExcludeMapBar {}');
// symlink directory in project directory in classmap
$this->fs->ensureDirectoryExists($this->workingDir.'/forks/bar/src/exclude');
$this->fs->ensureDirectoryExists($this->workingDir.'/composersrc/foo');
file_put_contents($this->workingDir.'/forks/bar/src/exclude/FooExclClass.php', '<?php class FooExclClass {};');
$target = $this->workingDir.'/forks/bar/';
2018-05-04 09:02:02 +00:00
$link = $this->workingDir.'/composersrc/foo/bar';
$command = Platform::isWindows()
2018-05-04 09:02:02 +00:00
? 'mklink /j "' . str_replace('/', '\\', $link) . '" "' . str_replace('/', '\\', $target) . '"'
: 'ln -s "' . $target . '" "' . $link . '"';
exec($command);
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', true, '_1');
// Assert that autoload_classmap.php was correctly generated.
$this->assertAutoloadFiles('classmap', $this->vendorDir.'/composer', 'classmap');
}
/**
* @param array<string, Link> $requires
* @param array<string, Link> $provides
* @param array<string, Link> $replaces
2022-02-22 15:47:09 +00:00
* @param bool|array<string> $ignorePlatformReqs
*
* @dataProvider platformCheckProvider
*/
2022-08-17 12:20:07 +00:00
public function testGeneratesPlatformCheck(array $requires, ?string $expectedFixture, array $provides = [], array $replaces = [], $ignorePlatformReqs = false): void
{
$package = new RootPackage('root/a', '1.0', '1.0');
$package->setRequires($requires);
if ($provides) {
$package->setProvides($provides);
}
if ($replaces) {
$package->setReplaces($replaces);
}
$this->repository->expects($this->once())
->method('getCanonicalPackages')
2022-08-17 12:20:07 +00:00
->will($this->returnValue([]));
$this->generator->setPlatformRequirementFilter(PlatformRequirementFilterFactory::fromBoolOrList($ignorePlatformReqs));
$this->generator->dump($this->config, $this->repository, $package, $this->im, 'composer', true, '_1');
if (null === $expectedFixture) {
$this->assertFileDoesNotExist($this->vendorDir . '/composer/platform_check.php');
$this->assertStringNotContainsString("require __DIR__ . '/platform_check.php';", (string) file_get_contents($this->vendorDir.'/composer/autoload_real.php'));
} else {
$this->assertFileContentEquals(__DIR__ . '/Fixtures/platform/' . $expectedFixture . '.php', $this->vendorDir . '/composer/platform_check.php');
$this->assertStringContainsString("require __DIR__ . '/platform_check.php';", (string) file_get_contents($this->vendorDir.'/composer/autoload_real.php'));
}
}
2021-10-16 09:13:29 +00:00
/**
* @return array<string, mixed[]>
*/
public static function platformCheckProvider(): array
{
$versionParser = new VersionParser();
2022-08-17 12:20:07 +00:00
return [
'Typical project requirements' => [
[
'php' => new Link('a', 'php', $versionParser->parseConstraints('^7.2')),
'ext-xml' => new Link('a', 'ext-xml', $versionParser->parseConstraints('*')),
'ext-json' => new Link('a', 'ext-json', $versionParser->parseConstraints('*')),
2022-08-17 12:20:07 +00:00
],
2020-11-22 13:48:56 +00:00
'typical',
2022-08-17 12:20:07 +00:00
],
'No PHP lower bound' => [
[
'php' => new Link('a', 'php', $versionParser->parseConstraints('< 8')),
2022-08-17 12:20:07 +00:00
],
2020-11-22 13:48:56 +00:00
null,
2022-08-17 12:20:07 +00:00
],
'No PHP upper bound' => [
[
'php' => new Link('a', 'php', $versionParser->parseConstraints('>= 7.2')),
2022-08-17 12:20:07 +00:00
],
2020-11-22 13:48:56 +00:00
'no_php_upper_bound',
2022-08-17 12:20:07 +00:00
],
'Specific PHP release version' => [
[
'php' => new Link('a', 'php', $versionParser->parseConstraints('^7.2.8')),
2022-08-17 12:20:07 +00:00
],
2020-11-22 13:48:56 +00:00
'specific_php_release',
2022-08-17 12:20:07 +00:00
],
'No PHP required' => [
[
'ext-xml' => new Link('a', 'ext-xml', $versionParser->parseConstraints('*')),
'ext-json' => new Link('a', 'ext-json', $versionParser->parseConstraints('*')),
2022-08-17 12:20:07 +00:00
],
2020-11-22 13:48:56 +00:00
'no_php_required',
2022-08-17 12:20:07 +00:00
],
'Ignoring all platform requirements skips check completely' => [
[
'php' => new Link('a', 'php', $versionParser->parseConstraints('^7.2')),
'ext-xml' => new Link('a', 'ext-xml', $versionParser->parseConstraints('*')),
'ext-json' => new Link('a', 'ext-json', $versionParser->parseConstraints('*')),
2022-08-17 12:20:07 +00:00
],
2020-06-01 14:01:43 +00:00
null,
2022-08-17 12:20:07 +00:00
[],
[],
2020-11-22 13:48:56 +00:00
true,
2022-08-17 12:20:07 +00:00
],
'Ignored platform requirements are not checked for' => [
[
'php' => new Link('a', 'php', $versionParser->parseConstraints('^7.2.8')),
'ext-xml' => new Link('a', 'ext-xml', $versionParser->parseConstraints('*')),
'ext-json' => new Link('a', 'ext-json', $versionParser->parseConstraints('*')),
'ext-pdo' => new Link('a', 'ext-pdo', $versionParser->parseConstraints('*')),
2022-08-17 12:20:07 +00:00
],
2020-06-01 14:01:43 +00:00
'no_php_required',
2022-08-17 12:20:07 +00:00
[],
[],
['php', 'ext-pdo'],
],
'Via wildcard ignored platform requirements are not checked for' => [
[
'php' => new Link('a', 'php', $versionParser->parseConstraints('^7.2.8')),
'ext-xml' => new Link('a', 'ext-xml', $versionParser->parseConstraints('*')),
'ext-json' => new Link('a', 'ext-json', $versionParser->parseConstraints('*')),
'ext-fileinfo' => new Link('a', 'ext-fileinfo', $versionParser->parseConstraints('*')),
'ext-filesystem' => new Link('a', 'ext-filesystem', $versionParser->parseConstraints('*')),
'ext-filter' => new Link('a', 'ext-filter', $versionParser->parseConstraints('*')),
2022-08-17 12:20:07 +00:00
],
'no_php_required',
2022-08-17 12:20:07 +00:00
[],
[],
['php', 'ext-fil*'],
],
'No extensions required' => [
[
'php' => new Link('a', 'php', $versionParser->parseConstraints('^7.2')),
2022-08-17 12:20:07 +00:00
],
2020-11-22 13:48:56 +00:00
'no_extensions_required',
2022-08-17 12:20:07 +00:00
],
'Replaced/provided extensions are not checked for + checking case insensitivity' => [
[
'ext-xml' => new Link('a', 'ext-xml', $versionParser->parseConstraints('^7.2')),
'ext-pdo' => new Link('a', 'ext-Pdo', $versionParser->parseConstraints('^7.2')),
'ext-bcmath' => new Link('a', 'ext-bcMath', $versionParser->parseConstraints('^7.2')),
2022-08-17 12:20:07 +00:00
],
'replaced_provided_exts',
2022-08-17 12:20:07 +00:00
[
// constraint does not satisfy all the ^7.2 requirement so we do not accept it as being replaced
'ext-pdo' => new Link('a', 'ext-PDO', $versionParser->parseConstraints('7.1.*')),
// valid replace of bcmath so no need to check for it
'ext-bcmath' => new Link('a', 'ext-BCMath', $versionParser->parseConstraints('^7.1')),
2022-08-17 12:20:07 +00:00
],
[
// valid provide of ext-xml so no need to check for it
'ext-xml' => new Link('a', 'ext-XML', $versionParser->parseConstraints('*')),
2022-08-17 12:20:07 +00:00
],
],
];
}
2022-02-22 15:47:09 +00:00
private function assertAutoloadFiles(string $name, string $dir, string $type = 'namespaces'): void
2011-12-03 22:20:06 +00:00
{
$a = __DIR__.'/Fixtures/autoload_'.$name.'.php';
$b = $dir.'/autoload_'.$type.'.php';
2020-02-07 03:18:45 +00:00
$this->assertFileContentEquals($a, $b);
2011-12-03 22:20:06 +00:00
}
public static function assertFileContentEquals(string $expected, string $actual, ?string $message = null): void
{
2021-12-10 12:14:04 +00:00
self::assertSame(
str_replace("\r", '', (string) file_get_contents($expected)),
str_replace("\r", '', (string) file_get_contents($actual)),
$message ?? $expected.' equals '.$actual
);
}
2011-12-03 22:20:06 +00:00
}