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