Actualización

vendor/symfony/cache/Tests/DependencyInjection/CacheCollectorPassTest.php

@@ -0,0 +1,49 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\DependencyInjection;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Cache\Adapter\FilesystemAdapter;
+use Symfony\Component\Cache\Adapter\TagAwareAdapter;
+use Symfony\Component\Cache\Adapter\TraceableAdapter;
+use Symfony\Component\Cache\Adapter\TraceableTagAwareAdapter;
+use Symfony\Component\Cache\DataCollector\CacheDataCollector;
+use Symfony\Component\Cache\DependencyInjection\CacheCollectorPass;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Reference;
+
+class CacheCollectorPassTest extends TestCase
+{
+    public function testProcess()
+    {
+        $container = new ContainerBuilder();
+        $container
+            ->register('fs', FilesystemAdapter::class)
+            ->addTag('cache.pool');
+        $container
+            ->register('tagged_fs', TagAwareAdapter::class)
+            ->addArgument(new Reference('fs'))
+            ->addTag('cache.pool');
+
+        $collector = $container->register('data_collector.cache', CacheDataCollector::class);
+        (new CacheCollectorPass())->process($container);
+
+        $this->assertEquals([
+            ['addInstance', ['fs', new Reference('fs')]],
+            ['addInstance', ['tagged_fs', new Reference('tagged_fs')]],
+        ], $collector->getMethodCalls());
+
+        $this->assertSame(TraceableAdapter::class, $container->findDefinition('fs')->getClass());
+        $this->assertSame(TraceableTagAwareAdapter::class, $container->getDefinition('tagged_fs')->getClass());
+        $this->assertFalse($collector->isPublic(), 'The "data_collector.cache" should be private after processing');
+    }
+}

vendor/symfony/cache/Tests/DependencyInjection/CachePoolClearerPassTest.php

@@ -0,0 +1,73 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\DependencyInjection;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Cache\DependencyInjection\CachePoolClearerPass;
+use Symfony\Component\Cache\DependencyInjection\CachePoolPass;
+use Symfony\Component\DependencyInjection\Compiler\RemoveUnusedDefinitionsPass;
+use Symfony\Component\DependencyInjection\Compiler\RepeatedPass;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\HttpKernel\CacheClearer\Psr6CacheClearer;
+
+class CachePoolClearerPassTest extends TestCase
+{
+    public function testPoolRefsAreWeak()
+    {
+        $container = new ContainerBuilder();
+        $container->setParameter('kernel.container_class', 'app');
+        $container->setParameter('kernel.project_dir', 'foo');
+
+        $globalClearer = new Definition(Psr6CacheClearer::class);
+        $container->setDefinition('cache.global_clearer', $globalClearer);
+
+        $publicPool = new Definition();
+        $publicPool->addArgument('namespace');
+        $publicPool->addTag('cache.pool', ['clearer' => 'clearer_alias']);
+        $container->setDefinition('public.pool', $publicPool);
+
+        $publicPool = new Definition();
+        $publicPool->addArgument('namespace');
+        $publicPool->addTag('cache.pool', ['clearer' => 'clearer_alias', 'name' => 'pool2']);
+        $container->setDefinition('public.pool2', $publicPool);
+
+        $privatePool = new Definition();
+        $privatePool->setPublic(false);
+        $privatePool->addArgument('namespace');
+        $privatePool->addTag('cache.pool', ['clearer' => 'clearer_alias']);
+        $container->setDefinition('private.pool', $privatePool);
+
+        $clearer = new Definition();
+        $container->setDefinition('clearer', $clearer);
+        $container->setAlias('clearer_alias', 'clearer');
+
+        $pass = new RemoveUnusedDefinitionsPass();
+        foreach ($container->getCompiler()->getPassConfig()->getRemovingPasses() as $removingPass) {
+            if ($removingPass instanceof RepeatedPass) {
+                $pass->setRepeatedPass(new RepeatedPass([$pass]));
+                break;
+            }
+        }
+        foreach ([new CachePoolPass(), $pass, new CachePoolClearerPass()] as $pass) {
+            $pass->process($container);
+        }
+
+        $expected = [[
+            'public.pool' => new Reference('public.pool'),
+            'pool2' => new Reference('public.pool2'),
+        ]];
+        $this->assertEquals($expected, $clearer->getArguments());
+        $this->assertEquals($expected, $globalClearer->getArguments());
+    }
+}

vendor/symfony/cache/Tests/DependencyInjection/CachePoolPassTest.php

@@ -0,0 +1,177 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\DependencyInjection;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Cache\Adapter\ArrayAdapter;
+use Symfony\Component\Cache\Adapter\RedisAdapter;
+use Symfony\Component\Cache\DependencyInjection\CachePoolPass;
+use Symfony\Component\DependencyInjection\ChildDefinition;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Reference;
+
+class CachePoolPassTest extends TestCase
+{
+    private $cachePoolPass;
+
+    protected function setUp(): void
+    {
+        $this->cachePoolPass = new CachePoolPass();
+    }
+
+    public function testNamespaceArgumentIsReplaced()
+    {
+        $container = new ContainerBuilder();
+        $container->setParameter('kernel.container_class', 'app');
+        $container->setParameter('kernel.project_dir', 'foo');
+        $adapter = new Definition();
+        $adapter->setAbstract(true);
+        $adapter->addTag('cache.pool');
+        $container->setDefinition('app.cache_adapter', $adapter);
+        $container->setAlias('app.cache_adapter_alias', 'app.cache_adapter');
+        $cachePool = new ChildDefinition('app.cache_adapter_alias');
+        $cachePool->addArgument(null);
+        $cachePool->addTag('cache.pool');
+        $container->setDefinition('app.cache_pool', $cachePool);
+
+        $this->cachePoolPass->process($container);
+
+        $this->assertSame('z3X945Jbf5', $cachePool->getArgument(0));
+    }
+
+    public function testNamespaceArgumentIsSeededWithAdapterClassName()
+    {
+        $container = new ContainerBuilder();
+        $container->setParameter('kernel.container_class', 'app');
+        $container->setParameter('kernel.project_dir', 'foo');
+        $adapter = new Definition();
+        $adapter->setAbstract(true);
+        $adapter->addTag('cache.pool');
+        $adapter->setClass(RedisAdapter::class);
+        $container->setDefinition('app.cache_adapter', $adapter);
+        $container->setAlias('app.cache_adapter_alias', 'app.cache_adapter');
+        $cachePool = new ChildDefinition('app.cache_adapter_alias');
+        $cachePool->addArgument(null);
+        $cachePool->addTag('cache.pool');
+        $container->setDefinition('app.cache_pool', $cachePool);
+
+        $this->cachePoolPass->process($container);
+
+        $this->assertSame('xmOJ8gqF-Y', $cachePool->getArgument(0));
+    }
+
+    public function testNamespaceArgumentIsSeededWithAdapterClassNameWithoutAffectingOtherCachePools()
+    {
+        $container = new ContainerBuilder();
+        $container->setParameter('kernel.container_class', 'app');
+        $container->setParameter('kernel.project_dir', 'foo');
+        $adapter = new Definition();
+        $adapter->setAbstract(true);
+        $adapter->addTag('cache.pool');
+        $adapter->setClass(RedisAdapter::class);
+        $container->setDefinition('app.cache_adapter', $adapter);
+        $container->setAlias('app.cache_adapter_alias', 'app.cache_adapter');
+
+        $otherCachePool = new ChildDefinition('app.cache_adapter_alias');
+        $otherCachePool->addArgument(null);
+        $otherCachePool->addTag('cache.pool');
+        $container->setDefinition('app.other_cache_pool', $otherCachePool);
+
+        $cachePool = new ChildDefinition('app.cache_adapter_alias');
+        $cachePool->addArgument(null);
+        $cachePool->addTag('cache.pool');
+        $container->setDefinition('app.cache_pool', $cachePool);
+
+        $this->cachePoolPass->process($container);
+
+        $this->assertSame('xmOJ8gqF-Y', $cachePool->getArgument(0));
+    }
+
+    public function testNamespaceArgumentIsNotReplacedIfArrayAdapterIsUsed()
+    {
+        $container = new ContainerBuilder();
+        $container->setParameter('kernel.container_class', 'app');
+        $container->setParameter('kernel.project_dir', 'foo');
+
+        $container->register('cache.adapter.array', ArrayAdapter::class)->addArgument(0);
+
+        $cachePool = new ChildDefinition('cache.adapter.array');
+        $cachePool->addTag('cache.pool');
+        $container->setDefinition('app.cache_pool', $cachePool);
+
+        $this->cachePoolPass->process($container);
+
+        $this->assertCount(0, $container->getDefinition('app.cache_pool')->getArguments());
+    }
+
+    public function testArgsAreReplaced()
+    {
+        $container = new ContainerBuilder();
+        $container->setParameter('kernel.container_class', 'app');
+        $container->setParameter('cache.prefix.seed', 'foo');
+        $cachePool = new Definition();
+        $cachePool->addTag('cache.pool', [
+            'provider' => 'foobar',
+            'default_lifetime' => 3,
+        ]);
+        $cachePool->addArgument(null);
+        $cachePool->addArgument(null);
+        $cachePool->addArgument(null);
+        $container->setDefinition('app.cache_pool', $cachePool);
+
+        $this->cachePoolPass->process($container);
+
+        $this->assertInstanceOf(Reference::class, $cachePool->getArgument(0));
+        $this->assertSame('foobar', (string) $cachePool->getArgument(0));
+        $this->assertSame('tQNhcV-8xa', $cachePool->getArgument(1));
+        $this->assertSame(3, $cachePool->getArgument(2));
+    }
+
+    public function testWithNameAttribute()
+    {
+        $container = new ContainerBuilder();
+        $container->setParameter('kernel.container_class', 'app');
+        $container->setParameter('cache.prefix.seed', 'foo');
+        $cachePool = new Definition();
+        $cachePool->addTag('cache.pool', [
+            'name' => 'foobar',
+            'provider' => 'foobar',
+        ]);
+        $cachePool->addArgument(null);
+        $cachePool->addArgument(null);
+        $cachePool->addArgument(null);
+        $container->setDefinition('app.cache_pool', $cachePool);
+
+        $this->cachePoolPass->process($container);
+
+        $this->assertSame('+naTpPa4Sm', $cachePool->getArgument(1));
+    }
+
+    public function testThrowsExceptionWhenCachePoolTagHasUnknownAttributes()
+    {
+        $this->expectException('InvalidArgumentException');
+        $this->expectExceptionMessage('Invalid "cache.pool" tag for service "app.cache_pool": accepted attributes are');
+        $container = new ContainerBuilder();
+        $container->setParameter('kernel.container_class', 'app');
+        $container->setParameter('kernel.project_dir', 'foo');
+        $adapter = new Definition();
+        $adapter->setAbstract(true);
+        $adapter->addTag('cache.pool');
+        $container->setDefinition('app.cache_adapter', $adapter);
+        $cachePool = new ChildDefinition('app.cache_adapter');
+        $cachePool->addTag('cache.pool', ['foobar' => 123]);
+        $container->setDefinition('app.cache_pool', $cachePool);
+
+        $this->cachePoolPass->process($container);
+    }
+}

vendor/symfony/cache/Tests/DependencyInjection/CachePoolPrunerPassTest.php

@@ -0,0 +1,70 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\DependencyInjection;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Cache\Adapter\FilesystemAdapter;
+use Symfony\Component\Cache\Adapter\PhpFilesAdapter;
+use Symfony\Component\Cache\DependencyInjection\CachePoolPrunerPass;
+use Symfony\Component\DependencyInjection\Argument\IteratorArgument;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Reference;
+
+class CachePoolPrunerPassTest extends TestCase
+{
+    public function testCompilerPassReplacesCommandArgument()
+    {
+        $container = new ContainerBuilder();
+        $container->register('console.command.cache_pool_prune')->addArgument([]);
+        $container->register('pool.foo', FilesystemAdapter::class)->addTag('cache.pool');
+        $container->register('pool.bar', PhpFilesAdapter::class)->addTag('cache.pool');
+
+        $pass = new CachePoolPrunerPass();
+        $pass->process($container);
+
+        $expected = [
+            'pool.foo' => new Reference('pool.foo'),
+            'pool.bar' => new Reference('pool.bar'),
+        ];
+        $argument = $container->getDefinition('console.command.cache_pool_prune')->getArgument(0);
+
+        $this->assertInstanceOf(IteratorArgument::class, $argument);
+        $this->assertEquals($expected, $argument->getValues());
+    }
+
+    public function testCompilePassIsIgnoredIfCommandDoesNotExist()
+    {
+        $container = new ContainerBuilder();
+
+        $definitionsBefore = \count($container->getDefinitions());
+        $aliasesBefore = \count($container->getAliases());
+
+        $pass = new CachePoolPrunerPass();
+        $pass->process($container);
+
+        // the container is untouched (i.e. no new definitions or aliases)
+        $this->assertCount($definitionsBefore, $container->getDefinitions());
+        $this->assertCount($aliasesBefore, $container->getAliases());
+    }
+
+    public function testCompilerPassThrowsOnInvalidDefinitionClass()
+    {
+        $this->expectException('Symfony\Component\DependencyInjection\Exception\InvalidArgumentException');
+        $this->expectExceptionMessage('Class "Symfony\Component\Cache\Tests\DependencyInjection\NotFound" used for service "pool.not-found" cannot be found.');
+        $container = new ContainerBuilder();
+        $container->register('console.command.cache_pool_prune')->addArgument([]);
+        $container->register('pool.not-found', NotFound::class)->addTag('cache.pool');
+
+        $pass = new CachePoolPrunerPass();
+        $pass->process($container);
+    }
+}