www.aleph1.co.uk Git - yaffs-website/blob - vendor/symfony/dependency-injection/Tests/Compiler/InlineServiceDefinitionsPassTest.php

   1 <?php
   2
   3 /*
   4  * This file is part of the Symfony package.
   5  *
   6  * (c) Fabien Potencier <fabien@symfony.com>
   7  *
   8  * For the full copyright and license information, please view the LICENSE
   9  * file that was distributed with this source code.
  10  */
  11
  12 namespace Symfony\Component\DependencyInjection\Tests\Compiler;
  13
  14 use PHPUnit\Framework\TestCase;
  15 use Symfony\Component\DependencyInjection\Scope;
  16 use Symfony\Component\DependencyInjection\Definition;
  17 use Symfony\Component\DependencyInjection\Compiler\AnalyzeServiceReferencesPass;
  18 use Symfony\Component\DependencyInjection\Compiler\RepeatedPass;
  19 use Symfony\Component\DependencyInjection\Compiler\InlineServiceDefinitionsPass;
  20 use Symfony\Component\DependencyInjection\Reference;
  21 use Symfony\Component\DependencyInjection\ContainerBuilder;
  22
  23 class InlineServiceDefinitionsPassTest extends TestCase
  24 {
  25     public function testProcess()
  26     {
  27         $container = new ContainerBuilder();
  28         $container
  29             ->register('inlinable.service')
  30             ->setPublic(false)
  31         ;
  32
  33         $container
  34             ->register('service')
  35             ->setArguments(array(new Reference('inlinable.service')))
  36         ;
  37
  38         $this->process($container);
  39
  40         $arguments = $container->getDefinition('service')->getArguments();
  41         $this->assertInstanceOf('Symfony\Component\DependencyInjection\Definition', $arguments[0]);
  42         $this->assertSame($container->getDefinition('inlinable.service'), $arguments[0]);
  43     }
  44
  45     public function testProcessDoesNotInlinesWhenAliasedServiceIsShared()
  46     {
  47         $container = new ContainerBuilder();
  48         $container
  49             ->register('foo')
  50             ->setPublic(false)
  51         ;
  52         $container->setAlias('moo', 'foo');
  53
  54         $container
  55             ->register('service')
  56             ->setArguments(array($ref = new Reference('foo')))
  57         ;
  58
  59         $this->process($container);
  60
  61         $arguments = $container->getDefinition('service')->getArguments();
  62         $this->assertSame($ref, $arguments[0]);
  63     }
  64
  65     /**
  66      * @group legacy
  67      */
  68     public function testProcessDoesNotInlineWhenAliasedServiceIsNotOfPrototypeScope()
  69     {
  70         $container = new ContainerBuilder();
  71         $container
  72             ->register('foo')
  73             ->setPublic(false)
  74         ;
  75         $container->setAlias('moo', 'foo');
  76
  77         $container
  78             ->register('service')
  79             ->setArguments(array($ref = new Reference('foo')))
  80         ;
  81
  82         $this->process($container);
  83
  84         $arguments = $container->getDefinition('service')->getArguments();
  85         $this->assertSame($ref, $arguments[0]);
  86     }
  87
  88     public function testProcessDoesInlineNonSharedService()
  89     {
  90         $container = new ContainerBuilder();
  91         $container
  92             ->register('foo')
  93             ->setShared(false)
  94         ;
  95         $container
  96             ->register('bar')
  97             ->setPublic(false)
  98             ->setShared(false)
  99         ;
 100         $container->setAlias('moo', 'bar');
 101
 102         $container
 103             ->register('service')
 104             ->setArguments(array(new Reference('foo'), $ref = new Reference('moo'), new Reference('bar')))
 105         ;
 106
 107         $this->process($container);
 108
 109         $arguments = $container->getDefinition('service')->getArguments();
 110         $this->assertEquals($container->getDefinition('foo'), $arguments[0]);
 111         $this->assertNotSame($container->getDefinition('foo'), $arguments[0]);
 112         $this->assertSame($ref, $arguments[1]);
 113         $this->assertEquals($container->getDefinition('bar'), $arguments[2]);
 114         $this->assertNotSame($container->getDefinition('bar'), $arguments[2]);
 115     }
 116
 117     /**
 118      * @group legacy
 119      */
 120     public function testProcessDoesInlineServiceOfPrototypeScope()
 121     {
 122         $container = new ContainerBuilder();
 123         $container
 124             ->register('foo')
 125             ->setScope('prototype')
 126         ;
 127         $container
 128             ->register('bar')
 129             ->setPublic(false)
 130             ->setScope('prototype')
 131         ;
 132         $container->setAlias('moo', 'bar');
 133
 134         $container
 135             ->register('service')
 136             ->setArguments(array(new Reference('foo'), $ref = new Reference('moo'), new Reference('bar')))
 137         ;
 138
 139         $this->process($container);
 140
 141         $arguments = $container->getDefinition('service')->getArguments();
 142         $this->assertEquals($container->getDefinition('foo'), $arguments[0]);
 143         $this->assertNotSame($container->getDefinition('foo'), $arguments[0]);
 144         $this->assertSame($ref, $arguments[1]);
 145         $this->assertEquals($container->getDefinition('bar'), $arguments[2]);
 146         $this->assertNotSame($container->getDefinition('bar'), $arguments[2]);
 147     }
 148
 149     public function testProcessInlinesIfMultipleReferencesButAllFromTheSameDefinition()
 150     {
 151         $container = new ContainerBuilder();
 152
 153         $a = $container->register('a')->setPublic(false);
 154         $b = $container
 155             ->register('b')
 156             ->addArgument(new Reference('a'))
 157             ->addArgument(new Definition(null, array(new Reference('a'))))
 158         ;
 159
 160         $this->process($container);
 161
 162         $arguments = $b->getArguments();
 163         $this->assertSame($a, $arguments[0]);
 164
 165         $inlinedArguments = $arguments[1]->getArguments();
 166         $this->assertSame($a, $inlinedArguments[0]);
 167     }
 168
 169     public function testProcessInlinesPrivateFactoryReference()
 170     {
 171         $container = new ContainerBuilder();
 172
 173         $container->register('a')->setPublic(false);
 174         $b = $container
 175             ->register('b')
 176             ->setPublic(false)
 177             ->setFactory(array(new Reference('a'), 'a'))
 178         ;
 179
 180         $container
 181             ->register('foo')
 182             ->setArguments(array(
 183                 $ref = new Reference('b'),
 184             ));
 185
 186         $this->process($container);
 187
 188         $inlinedArguments = $container->getDefinition('foo')->getArguments();
 189         $this->assertSame($b, $inlinedArguments[0]);
 190     }
 191
 192     public function testProcessDoesNotInlinePrivateFactoryIfReferencedMultipleTimesWithinTheSameDefinition()
 193     {
 194         $container = new ContainerBuilder();
 195         $container
 196             ->register('a')
 197         ;
 198         $container
 199             ->register('b')
 200             ->setPublic(false)
 201             ->setFactory(array(new Reference('a'), 'a'))
 202         ;
 203
 204         $container
 205             ->register('foo')
 206             ->setArguments(array(
 207                     $ref1 = new Reference('b'),
 208                     $ref2 = new Reference('b'),
 209                 ))
 210         ;
 211         $this->process($container);
 212
 213         $args = $container->getDefinition('foo')->getArguments();
 214         $this->assertSame($ref1, $args[0]);
 215         $this->assertSame($ref2, $args[1]);
 216     }
 217
 218     public function testProcessDoesNotInlineReferenceWhenUsedByInlineFactory()
 219     {
 220         $container = new ContainerBuilder();
 221         $container
 222             ->register('a')
 223         ;
 224         $container
 225             ->register('b')
 226             ->setPublic(false)
 227             ->setFactory(array(new Reference('a'), 'a'))
 228         ;
 229
 230         $inlineFactory = new Definition();
 231         $inlineFactory->setPublic(false);
 232         $inlineFactory->setFactory(array(new Reference('b'), 'b'));
 233
 234         $container
 235             ->register('foo')
 236             ->setArguments(array(
 237                     $ref = new Reference('b'),
 238                     $inlineFactory,
 239                 ))
 240         ;
 241         $this->process($container);
 242
 243         $args = $container->getDefinition('foo')->getArguments();
 244         $this->assertSame($ref, $args[0]);
 245     }
 246
 247     /**
 248      * @group legacy
 249      */
 250     public function testProcessInlinesOnlyIfSameScope()
 251     {
 252         $container = new ContainerBuilder();
 253
 254         $container->addScope(new Scope('foo'));
 255         $a = $container->register('a')->setPublic(false)->setScope('foo');
 256         $b = $container->register('b')->addArgument(new Reference('a'));
 257
 258         $this->process($container);
 259         $arguments = $b->getArguments();
 260         $this->assertEquals(new Reference('a'), $arguments[0]);
 261         $this->assertTrue($container->hasDefinition('a'));
 262     }
 263
 264     public function testProcessDoesNotInlineWhenServiceIsPrivateButLazy()
 265     {
 266         $container = new ContainerBuilder();
 267         $container
 268             ->register('foo')
 269             ->setPublic(false)
 270             ->setLazy(true)
 271         ;
 272
 273         $container
 274             ->register('service')
 275             ->setArguments(array($ref = new Reference('foo')))
 276         ;
 277
 278         $this->process($container);
 279
 280         $arguments = $container->getDefinition('service')->getArguments();
 281         $this->assertSame($ref, $arguments[0]);
 282     }
 283
 284     public function testProcessDoesNotInlineWhenServiceReferencesItself()
 285     {
 286         $container = new ContainerBuilder();
 287         $container
 288             ->register('foo')
 289             ->setPublic(false)
 290             ->addMethodCall('foo', array($ref = new Reference('foo')))
 291         ;
 292
 293         $this->process($container);
 294
 295         $calls = $container->getDefinition('foo')->getMethodCalls();
 296         $this->assertSame($ref, $calls[0][1][0]);
 297     }
 298
 299     protected function process(ContainerBuilder $container)
 300     {
 301         $repeatedPass = new RepeatedPass(array(new AnalyzeServiceReferencesPass(), new InlineServiceDefinitionsPass()));
 302         $repeatedPass->process($container);
 303     }
 304 }