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\Definition;
  16 use Symfony\Component\DependencyInjection\Compiler\AnalyzeServiceReferencesPass;
  17 use Symfony\Component\DependencyInjection\Compiler\RepeatedPass;
  18 use Symfony\Component\DependencyInjection\Compiler\InlineServiceDefinitionsPass;
  19 use Symfony\Component\DependencyInjection\Reference;
  20 use Symfony\Component\DependencyInjection\ContainerBuilder;
  21
  22 class InlineServiceDefinitionsPassTest extends TestCase
  23 {
  24     public function testProcess()
  25     {
  26         $container = new ContainerBuilder();
  27         $container
  28             ->register('inlinable.service')
  29             ->setPublic(false)
  30         ;
  31
  32         $container
  33             ->register('service')
  34             ->setArguments(array(new Reference('inlinable.service')))
  35         ;
  36
  37         $this->process($container);
  38
  39         $arguments = $container->getDefinition('service')->getArguments();
  40         $this->assertInstanceOf('Symfony\Component\DependencyInjection\Definition', $arguments[0]);
  41         $this->assertSame($container->getDefinition('inlinable.service'), $arguments[0]);
  42     }
  43
  44     public function testProcessDoesNotInlinesWhenAliasedServiceIsShared()
  45     {
  46         $container = new ContainerBuilder();
  47         $container
  48             ->register('foo')
  49             ->setPublic(false)
  50         ;
  51         $container->setAlias('moo', 'foo');
  52
  53         $container
  54             ->register('service')
  55             ->setArguments(array($ref = new Reference('foo')))
  56         ;
  57
  58         $this->process($container);
  59
  60         $arguments = $container->getDefinition('service')->getArguments();
  61         $this->assertSame($ref, $arguments[0]);
  62     }
  63
  64     public function testProcessDoesInlineNonSharedService()
  65     {
  66         $container = new ContainerBuilder();
  67         $container
  68             ->register('foo')
  69             ->setShared(false)
  70         ;
  71         $container
  72             ->register('bar')
  73             ->setPublic(false)
  74             ->setShared(false)
  75         ;
  76         $container->setAlias('moo', 'bar');
  77
  78         $container
  79             ->register('service')
  80             ->setArguments(array(new Reference('foo'), $ref = new Reference('moo'), new Reference('bar')))
  81         ;
  82
  83         $this->process($container);
  84
  85         $arguments = $container->getDefinition('service')->getArguments();
  86         $this->assertEquals($container->getDefinition('foo'), $arguments[0]);
  87         $this->assertNotSame($container->getDefinition('foo'), $arguments[0]);
  88         $this->assertSame($ref, $arguments[1]);
  89         $this->assertEquals($container->getDefinition('bar'), $arguments[2]);
  90         $this->assertNotSame($container->getDefinition('bar'), $arguments[2]);
  91     }
  92
  93     public function testProcessInlinesIfMultipleReferencesButAllFromTheSameDefinition()
  94     {
  95         $container = new ContainerBuilder();
  96
  97         $a = $container->register('a')->setPublic(false);
  98         $b = $container
  99             ->register('b')
 100             ->addArgument(new Reference('a'))
 101             ->addArgument(new Definition(null, array(new Reference('a'))))
 102         ;
 103
 104         $this->process($container);
 105
 106         $arguments = $b->getArguments();
 107         $this->assertSame($a, $arguments[0]);
 108
 109         $inlinedArguments = $arguments[1]->getArguments();
 110         $this->assertSame($a, $inlinedArguments[0]);
 111     }
 112
 113     public function testProcessInlinesPrivateFactoryReference()
 114     {
 115         $container = new ContainerBuilder();
 116
 117         $container->register('a')->setPublic(false);
 118         $b = $container
 119             ->register('b')
 120             ->setPublic(false)
 121             ->setFactory(array(new Reference('a'), 'a'))
 122         ;
 123
 124         $container
 125             ->register('foo')
 126             ->setArguments(array(
 127                 $ref = new Reference('b'),
 128             ));
 129
 130         $this->process($container);
 131
 132         $inlinedArguments = $container->getDefinition('foo')->getArguments();
 133         $this->assertSame($b, $inlinedArguments[0]);
 134     }
 135
 136     public function testProcessDoesNotInlinePrivateFactoryIfReferencedMultipleTimesWithinTheSameDefinition()
 137     {
 138         $container = new ContainerBuilder();
 139         $container
 140             ->register('a')
 141         ;
 142         $container
 143             ->register('b')
 144             ->setPublic(false)
 145             ->setFactory(array(new Reference('a'), 'a'))
 146         ;
 147
 148         $container
 149             ->register('foo')
 150             ->setArguments(array(
 151                     $ref1 = new Reference('b'),
 152                     $ref2 = new Reference('b'),
 153                 ))
 154         ;
 155         $this->process($container);
 156
 157         $args = $container->getDefinition('foo')->getArguments();
 158         $this->assertSame($ref1, $args[0]);
 159         $this->assertSame($ref2, $args[1]);
 160     }
 161
 162     public function testProcessDoesNotInlineReferenceWhenUsedByInlineFactory()
 163     {
 164         $container = new ContainerBuilder();
 165         $container
 166             ->register('a')
 167         ;
 168         $container
 169             ->register('b')
 170             ->setPublic(false)
 171             ->setFactory(array(new Reference('a'), 'a'))
 172         ;
 173
 174         $inlineFactory = new Definition();
 175         $inlineFactory->setPublic(false);
 176         $inlineFactory->setFactory(array(new Reference('b'), 'b'));
 177
 178         $container
 179             ->register('foo')
 180             ->setArguments(array(
 181                     $ref = new Reference('b'),
 182                     $inlineFactory,
 183                 ))
 184         ;
 185         $this->process($container);
 186
 187         $args = $container->getDefinition('foo')->getArguments();
 188         $this->assertSame($ref, $args[0]);
 189     }
 190
 191     public function testProcessDoesNotInlineWhenServiceIsPrivateButLazy()
 192     {
 193         $container = new ContainerBuilder();
 194         $container
 195             ->register('foo')
 196             ->setPublic(false)
 197             ->setLazy(true)
 198         ;
 199
 200         $container
 201             ->register('service')
 202             ->setArguments(array($ref = new Reference('foo')))
 203         ;
 204
 205         $this->process($container);
 206
 207         $arguments = $container->getDefinition('service')->getArguments();
 208         $this->assertSame($ref, $arguments[0]);
 209     }
 210
 211     public function testProcessDoesNotInlineWhenServiceReferencesItself()
 212     {
 213         $container = new ContainerBuilder();
 214         $container
 215             ->register('foo')
 216             ->setPublic(false)
 217             ->addMethodCall('foo', array($ref = new Reference('foo')))
 218         ;
 219
 220         $this->process($container);
 221
 222         $calls = $container->getDefinition('foo')->getMethodCalls();
 223         $this->assertSame($ref, $calls[0][1][0]);
 224     }
 225
 226     protected function process(ContainerBuilder $container)
 227     {
 228         $repeatedPass = new RepeatedPass(array(new AnalyzeServiceReferencesPass(), new InlineServiceDefinitionsPass()));
 229         $repeatedPass->process($container);
 230     }
 231 }