yaffs.net Git - yaffs-website/blob - vendor/symfony/dependency-injection/Tests/Compiler/ResolveDefinitionTemplatesPassTest.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\ContainerInterface;
  16 use Symfony\Component\DependencyInjection\DefinitionDecorator;
  17 use Symfony\Component\DependencyInjection\Compiler\ResolveDefinitionTemplatesPass;
  18 use Symfony\Component\DependencyInjection\ContainerBuilder;
  19
  20 class ResolveDefinitionTemplatesPassTest extends TestCase
  21 {
  22     public function testProcess()
  23     {
  24         $container = new ContainerBuilder();
  25         $container->register('parent', 'foo')->setArguments(array('moo', 'b'))->setProperty('foo', 'moo');
  26         $container->setDefinition('child', new DefinitionDecorator('parent'))
  27             ->replaceArgument(0, 'a')
  28             ->setProperty('foo', 'bar')
  29             ->setClass('bar')
  30         ;
  31
  32         $this->process($container);
  33
  34         $def = $container->getDefinition('child');
  35         $this->assertNotInstanceOf('Symfony\Component\DependencyInjection\DefinitionDecorator', $def);
  36         $this->assertEquals('bar', $def->getClass());
  37         $this->assertEquals(array('a', 'b'), $def->getArguments());
  38         $this->assertEquals(array('foo' => 'bar'), $def->getProperties());
  39     }
  40
  41     public function testProcessAppendsMethodCallsAlways()
  42     {
  43         $container = new ContainerBuilder();
  44
  45         $container
  46             ->register('parent')
  47             ->addMethodCall('foo', array('bar'))
  48         ;
  49
  50         $container
  51             ->setDefinition('child', new DefinitionDecorator('parent'))
  52             ->addMethodCall('bar', array('foo'))
  53         ;
  54
  55         $this->process($container);
  56
  57         $def = $container->getDefinition('child');
  58         $this->assertEquals(array(
  59             array('foo', array('bar')),
  60             array('bar', array('foo')),
  61         ), $def->getMethodCalls());
  62     }
  63
  64     public function testProcessDoesNotCopyAbstract()
  65     {
  66         $container = new ContainerBuilder();
  67
  68         $container
  69             ->register('parent')
  70             ->setAbstract(true)
  71         ;
  72
  73         $container
  74             ->setDefinition('child', new DefinitionDecorator('parent'))
  75         ;
  76
  77         $this->process($container);
  78
  79         $def = $container->getDefinition('child');
  80         $this->assertFalse($def->isAbstract());
  81     }
  82
  83     /**
  84      * @group legacy
  85      */
  86     public function testProcessDoesNotCopyScope()
  87     {
  88         $container = new ContainerBuilder();
  89
  90         $container
  91             ->register('parent')
  92             ->setScope('foo')
  93         ;
  94
  95         $container
  96             ->setDefinition('child', new DefinitionDecorator('parent'))
  97         ;
  98
  99         $this->process($container);
 100
 101         $def = $container->getDefinition('child');
 102         $this->assertEquals(ContainerInterface::SCOPE_CONTAINER, $def->getScope());
 103     }
 104
 105     public function testProcessDoesNotCopyShared()
 106     {
 107         $container = new ContainerBuilder();
 108
 109         $container
 110             ->register('parent')
 111             ->setShared(false)
 112         ;
 113
 114         $container
 115             ->setDefinition('child', new DefinitionDecorator('parent'))
 116         ;
 117
 118         $this->process($container);
 119
 120         $def = $container->getDefinition('child');
 121         $this->assertTrue($def->isShared());
 122     }
 123
 124     public function testProcessDoesNotCopyTags()
 125     {
 126         $container = new ContainerBuilder();
 127
 128         $container
 129             ->register('parent')
 130             ->addTag('foo')
 131         ;
 132
 133         $container
 134             ->setDefinition('child', new DefinitionDecorator('parent'))
 135         ;
 136
 137         $this->process($container);
 138
 139         $def = $container->getDefinition('child');
 140         $this->assertEquals(array(), $def->getTags());
 141     }
 142
 143     public function testProcessDoesNotCopyDecoratedService()
 144     {
 145         $container = new ContainerBuilder();
 146
 147         $container
 148             ->register('parent')
 149             ->setDecoratedService('foo')
 150         ;
 151
 152         $container
 153             ->setDefinition('child', new DefinitionDecorator('parent'))
 154         ;
 155
 156         $this->process($container);
 157
 158         $def = $container->getDefinition('child');
 159         $this->assertNull($def->getDecoratedService());
 160     }
 161
 162     public function testProcessDoesNotDropShared()
 163     {
 164         $container = new ContainerBuilder();
 165
 166         $container
 167             ->register('parent')
 168         ;
 169
 170         $container
 171             ->setDefinition('child', new DefinitionDecorator('parent'))
 172             ->setShared(false)
 173         ;
 174
 175         $this->process($container);
 176
 177         $def = $container->getDefinition('child');
 178         $this->assertFalse($def->isShared());
 179     }
 180
 181     public function testProcessHandlesMultipleInheritance()
 182     {
 183         $container = new ContainerBuilder();
 184
 185         $container
 186             ->register('parent', 'foo')
 187             ->setArguments(array('foo', 'bar', 'c'))
 188         ;
 189
 190         $container
 191             ->setDefinition('child2', new DefinitionDecorator('child1'))
 192             ->replaceArgument(1, 'b')
 193         ;
 194
 195         $container
 196             ->setDefinition('child1', new DefinitionDecorator('parent'))
 197             ->replaceArgument(0, 'a')
 198         ;
 199
 200         $this->process($container);
 201
 202         $def = $container->getDefinition('child2');
 203         $this->assertEquals(array('a', 'b', 'c'), $def->getArguments());
 204         $this->assertEquals('foo', $def->getClass());
 205     }
 206
 207     public function testSetLazyOnServiceHasParent()
 208     {
 209         $container = new ContainerBuilder();
 210
 211         $container->register('parent', 'stdClass');
 212
 213         $container->setDefinition('child1', new DefinitionDecorator('parent'))
 214             ->setLazy(true)
 215         ;
 216
 217         $this->process($container);
 218
 219         $this->assertTrue($container->getDefinition('child1')->isLazy());
 220     }
 221
 222     public function testSetLazyOnServiceIsParent()
 223     {
 224         $container = new ContainerBuilder();
 225
 226         $container->register('parent', 'stdClass')
 227             ->setLazy(true)
 228         ;
 229
 230         $container->setDefinition('child1', new DefinitionDecorator('parent'));
 231
 232         $this->process($container);
 233
 234         $this->assertTrue($container->getDefinition('child1')->isLazy());
 235     }
 236
 237     public function testSetAutowiredOnServiceHasParent()
 238     {
 239         $container = new ContainerBuilder();
 240
 241         $container->register('parent', 'stdClass');
 242
 243         $container->setDefinition('child1', new DefinitionDecorator('parent'))
 244             ->setAutowired(true)
 245         ;
 246
 247         $this->process($container);
 248
 249         $this->assertTrue($container->getDefinition('child1')->isAutowired());
 250     }
 251
 252     public function testSetAutowiredOnServiceIsParent()
 253     {
 254         $container = new ContainerBuilder();
 255
 256         $container->register('parent', 'stdClass')
 257             ->setAutowired(true)
 258         ;
 259
 260         $container->setDefinition('child1', new DefinitionDecorator('parent'));
 261
 262         $this->process($container);
 263
 264         $this->assertTrue($container->getDefinition('child1')->isAutowired());
 265     }
 266
 267     public function testDeepDefinitionsResolving()
 268     {
 269         $container = new ContainerBuilder();
 270
 271         $container->register('parent', 'parentClass');
 272         $container->register('sibling', 'siblingClass')
 273             ->setConfigurator(new DefinitionDecorator('parent'), 'foo')
 274             ->setFactory(array(new DefinitionDecorator('parent'), 'foo'))
 275             ->addArgument(new DefinitionDecorator('parent'))
 276             ->setProperty('prop', new DefinitionDecorator('parent'))
 277             ->addMethodCall('meth', array(new DefinitionDecorator('parent')))
 278         ;
 279
 280         $this->process($container);
 281
 282         $configurator = $container->getDefinition('sibling')->getConfigurator();
 283         $this->assertSame('Symfony\Component\DependencyInjection\Definition', get_class($configurator));
 284         $this->assertSame('parentClass', $configurator->getClass());
 285
 286         $factory = $container->getDefinition('sibling')->getFactory();
 287         $this->assertSame('Symfony\Component\DependencyInjection\Definition', get_class($factory[0]));
 288         $this->assertSame('parentClass', $factory[0]->getClass());
 289
 290         $argument = $container->getDefinition('sibling')->getArgument(0);
 291         $this->assertSame('Symfony\Component\DependencyInjection\Definition', get_class($argument));
 292         $this->assertSame('parentClass', $argument->getClass());
 293
 294         $properties = $container->getDefinition('sibling')->getProperties();
 295         $this->assertSame('Symfony\Component\DependencyInjection\Definition', get_class($properties['prop']));
 296         $this->assertSame('parentClass', $properties['prop']->getClass());
 297
 298         $methodCalls = $container->getDefinition('sibling')->getMethodCalls();
 299         $this->assertSame('Symfony\Component\DependencyInjection\Definition', get_class($methodCalls[0][1][0]));
 300         $this->assertSame('parentClass', $methodCalls[0][1][0]->getClass());
 301     }
 302
 303     public function testSetDecoratedServiceOnServiceHasParent()
 304     {
 305         $container = new ContainerBuilder();
 306
 307         $container->register('parent', 'stdClass');
 308
 309         $container->setDefinition('child1', new DefinitionDecorator('parent'))
 310             ->setDecoratedService('foo', 'foo_inner', 5)
 311         ;
 312
 313         $this->process($container);
 314
 315         $this->assertEquals(array('foo', 'foo_inner', 5), $container->getDefinition('child1')->getDecoratedService());
 316     }
 317
 318     public function testDecoratedServiceCopiesDeprecatedStatusFromParent()
 319     {
 320         $container = new ContainerBuilder();
 321         $container->register('deprecated_parent')
 322             ->setDeprecated(true)
 323         ;
 324
 325         $container->setDefinition('decorated_deprecated_parent', new DefinitionDecorator('deprecated_parent'));
 326
 327         $this->process($container);
 328
 329         $this->assertTrue($container->getDefinition('decorated_deprecated_parent')->isDeprecated());
 330     }
 331
 332     public function testDecoratedServiceCanOverwriteDeprecatedParentStatus()
 333     {
 334         $container = new ContainerBuilder();
 335         $container->register('deprecated_parent')
 336             ->setDeprecated(true)
 337         ;
 338
 339         $container->setDefinition('decorated_deprecated_parent', new DefinitionDecorator('deprecated_parent'))
 340             ->setDeprecated(false)
 341         ;
 342
 343         $this->process($container);
 344
 345         $this->assertFalse($container->getDefinition('decorated_deprecated_parent')->isDeprecated());
 346     }
 347
 348     public function testProcessMergeAutowiringTypes()
 349     {
 350         $container = new ContainerBuilder();
 351
 352         $container
 353             ->register('parent')
 354             ->addAutowiringType('Foo')
 355         ;
 356
 357         $container
 358             ->setDefinition('child', new DefinitionDecorator('parent'))
 359             ->addAutowiringType('Bar')
 360         ;
 361
 362         $this->process($container);
 363
 364         $childDef = $container->getDefinition('child');
 365         $this->assertEquals(array('Foo', 'Bar'), $childDef->getAutowiringTypes());
 366
 367         $parentDef = $container->getDefinition('parent');
 368         $this->assertSame(array('Foo'), $parentDef->getAutowiringTypes());
 369     }
 370
 371     protected function process(ContainerBuilder $container)
 372     {
 373         $pass = new ResolveDefinitionTemplatesPass();
 374         $pass->process($container);
 375     }
 376 }