www.aleph1.co.uk Git - yaffs-website/blob - vendor/symfony/dependency-injection/Tests/ContainerBuilderTest.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;
  13
  14 require_once __DIR__.'/Fixtures/includes/classes.php';
  15 require_once __DIR__.'/Fixtures/includes/ProjectExtension.php';
  16
  17 use PHPUnit\Framework\TestCase;
  18 use Symfony\Component\Config\Resource\ResourceInterface;
  19 use Symfony\Component\DependencyInjection\Alias;
  20 use Symfony\Component\DependencyInjection\ContainerBuilder;
  21 use Symfony\Component\DependencyInjection\ContainerInterface;
  22 use Symfony\Component\DependencyInjection\Definition;
  23 use Symfony\Component\DependencyInjection\DefinitionDecorator;
  24 use Symfony\Component\DependencyInjection\Exception\RuntimeException;
  25 use Symfony\Component\DependencyInjection\Exception\InactiveScopeException;
  26 use Symfony\Component\DependencyInjection\Exception\ServiceCircularReferenceException;
  27 use Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException;
  28 use Symfony\Component\DependencyInjection\Loader\ClosureLoader;
  29 use Symfony\Component\DependencyInjection\Reference;
  30 use Symfony\Component\DependencyInjection\ParameterBag\ParameterBag;
  31 use Symfony\Component\DependencyInjection\Scope;
  32 use Symfony\Component\Config\Resource\FileResource;
  33 use Symfony\Component\DependencyInjection\Tests\Fixtures\CustomDefinition;
  34 use Symfony\Component\ExpressionLanguage\Expression;
  35
  36 class ContainerBuilderTest extends TestCase
  37 {
  38     public function testDefinitions()
  39     {
  40         $builder = new ContainerBuilder();
  41         $definitions = array(
  42             'foo' => new Definition('Bar\FooClass'),
  43             'bar' => new Definition('BarClass'),
  44         );
  45         $builder->setDefinitions($definitions);
  46         $this->assertEquals($definitions, $builder->getDefinitions(), '->setDefinitions() sets the service definitions');
  47         $this->assertTrue($builder->hasDefinition('foo'), '->hasDefinition() returns true if a service definition exists');
  48         $this->assertFalse($builder->hasDefinition('foobar'), '->hasDefinition() returns false if a service definition does not exist');
  49
  50         $builder->setDefinition('foobar', $foo = new Definition('FooBarClass'));
  51         $this->assertEquals($foo, $builder->getDefinition('foobar'), '->getDefinition() returns a service definition if defined');
  52         $this->assertTrue($builder->setDefinition('foobar', $foo = new Definition('FooBarClass')) === $foo, '->setDefinition() implements a fluid interface by returning the service reference');
  53
  54         $builder->addDefinitions($defs = array('foobar' => new Definition('FooBarClass')));
  55         $this->assertEquals(array_merge($definitions, $defs), $builder->getDefinitions(), '->addDefinitions() adds the service definitions');
  56
  57         try {
  58             $builder->getDefinition('baz');
  59             $this->fail('->getDefinition() throws a ServiceNotFoundException if the service definition does not exist');
  60         } catch (ServiceNotFoundException $e) {
  61             $this->assertEquals('You have requested a non-existent service "baz".', $e->getMessage(), '->getDefinition() throws a ServiceNotFoundException if the service definition does not exist');
  62         }
  63     }
  64
  65     /**
  66      * @group legacy
  67      * @expectedDeprecation The "deprecated_foo" service is deprecated. You should stop using it, as it will soon be removed.
  68      */
  69     public function testCreateDeprecatedService()
  70     {
  71         $definition = new Definition('stdClass');
  72         $definition->setDeprecated(true);
  73
  74         $builder = new ContainerBuilder();
  75         $builder->createService($definition, 'deprecated_foo');
  76     }
  77
  78     public function testRegister()
  79     {
  80         $builder = new ContainerBuilder();
  81         $builder->register('foo', 'Bar\FooClass');
  82         $this->assertTrue($builder->hasDefinition('foo'), '->register() registers a new service definition');
  83         $this->assertInstanceOf('Symfony\Component\DependencyInjection\Definition', $builder->getDefinition('foo'), '->register() returns the newly created Definition instance');
  84     }
  85
  86     public function testHas()
  87     {
  88         $builder = new ContainerBuilder();
  89         $this->assertFalse($builder->has('foo'), '->has() returns false if the service does not exist');
  90         $builder->register('foo', 'Bar\FooClass');
  91         $this->assertTrue($builder->has('foo'), '->has() returns true if a service definition exists');
  92         $builder->set('bar', new \stdClass());
  93         $this->assertTrue($builder->has('bar'), '->has() returns true if a service exists');
  94     }
  95
  96     public function testGet()
  97     {
  98         $builder = new ContainerBuilder();
  99         try {
 100             $builder->get('foo');
 101             $this->fail('->get() throws a ServiceNotFoundException if the service does not exist');
 102         } catch (ServiceNotFoundException $e) {
 103             $this->assertEquals('You have requested a non-existent service "foo".', $e->getMessage(), '->get() throws a ServiceNotFoundException if the service does not exist');
 104         }
 105
 106         $this->assertNull($builder->get('foo', ContainerInterface::NULL_ON_INVALID_REFERENCE), '->get() returns null if the service does not exist and NULL_ON_INVALID_REFERENCE is passed as a second argument');
 107
 108         $builder->register('foo', 'stdClass');
 109         $this->assertInternalType('object', $builder->get('foo'), '->get() returns the service definition associated with the id');
 110         $builder->set('bar', $bar = new \stdClass());
 111         $this->assertEquals($bar, $builder->get('bar'), '->get() returns the service associated with the id');
 112         $builder->register('bar', 'stdClass');
 113         $this->assertEquals($bar, $builder->get('bar'), '->get() returns the service associated with the id even if a definition has been defined');
 114
 115         $builder->register('baz', 'stdClass')->setArguments(array(new Reference('baz')));
 116         try {
 117             @$builder->get('baz');
 118             $this->fail('->get() throws a ServiceCircularReferenceException if the service has a circular reference to itself');
 119         } catch (ServiceCircularReferenceException $e) {
 120             $this->assertEquals('Circular reference detected for service "baz", path: "baz".', $e->getMessage(), '->get() throws a LogicException if the service has a circular reference to itself');
 121         }
 122
 123         $this->assertTrue($builder->get('bar') === $builder->get('bar'), '->get() always returns the same instance if the service is shared');
 124     }
 125
 126     public function testNonSharedServicesReturnsDifferentInstances()
 127     {
 128         $builder = new ContainerBuilder();
 129         $builder->register('bar', 'stdClass')->setShared(false);
 130
 131         $this->assertNotSame($builder->get('bar'), $builder->get('bar'));
 132     }
 133
 134     /**
 135      * @expectedException        \Symfony\Component\DependencyInjection\Exception\RuntimeException
 136      * @expectedExceptionMessage You have requested a synthetic service ("foo"). The DIC does not know how to construct this service.
 137      */
 138     public function testGetUnsetLoadingServiceWhenCreateServiceThrowsAnException()
 139     {
 140         $builder = new ContainerBuilder();
 141         $builder->register('foo', 'stdClass')->setSynthetic(true);
 142
 143         // we expect a RuntimeException here as foo is synthetic
 144         try {
 145             $builder->get('foo');
 146         } catch (RuntimeException $e) {
 147         }
 148
 149         // we must also have the same RuntimeException here
 150         $builder->get('foo');
 151     }
 152
 153     /**
 154      * @group legacy
 155      */
 156     public function testGetReturnsNullOnInactiveScope()
 157     {
 158         $builder = new ContainerBuilder();
 159         $builder->register('foo', 'stdClass')->setScope('request');
 160
 161         $this->assertNull($builder->get('foo', ContainerInterface::NULL_ON_INVALID_REFERENCE));
 162     }
 163
 164     /**
 165      * @group legacy
 166      */
 167     public function testGetReturnsNullOnInactiveScopeWhenServiceIsCreatedByAMethod()
 168     {
 169         $builder = new ProjectContainer();
 170
 171         $this->assertNull($builder->get('foobaz', ContainerInterface::NULL_ON_INVALID_REFERENCE));
 172     }
 173
 174     public function testGetServiceIds()
 175     {
 176         $builder = new ContainerBuilder();
 177         $builder->register('foo', 'stdClass');
 178         $builder->bar = $bar = new \stdClass();
 179         $builder->register('bar', 'stdClass');
 180         $this->assertEquals(array('foo', 'bar', 'service_container'), $builder->getServiceIds(), '->getServiceIds() returns all defined service ids');
 181     }
 182
 183     public function testAliases()
 184     {
 185         $builder = new ContainerBuilder();
 186         $builder->register('foo', 'stdClass');
 187         $builder->setAlias('bar', 'foo');
 188         $this->assertTrue($builder->hasAlias('bar'), '->hasAlias() returns true if the alias exists');
 189         $this->assertFalse($builder->hasAlias('foobar'), '->hasAlias() returns false if the alias does not exist');
 190         $this->assertEquals('foo', (string) $builder->getAlias('bar'), '->getAlias() returns the aliased service');
 191         $this->assertTrue($builder->has('bar'), '->setAlias() defines a new service');
 192         $this->assertTrue($builder->get('bar') === $builder->get('foo'), '->setAlias() creates a service that is an alias to another one');
 193
 194         try {
 195             $builder->setAlias('foobar', 'foobar');
 196             $this->fail('->setAlias() throws an InvalidArgumentException if the alias references itself');
 197         } catch (\InvalidArgumentException $e) {
 198             $this->assertEquals('An alias can not reference itself, got a circular reference on "foobar".', $e->getMessage(), '->setAlias() throws an InvalidArgumentException if the alias references itself');
 199         }
 200
 201         try {
 202             $builder->getAlias('foobar');
 203             $this->fail('->getAlias() throws an InvalidArgumentException if the alias does not exist');
 204         } catch (\InvalidArgumentException $e) {
 205             $this->assertEquals('The service alias "foobar" does not exist.', $e->getMessage(), '->getAlias() throws an InvalidArgumentException if the alias does not exist');
 206         }
 207     }
 208
 209     public function testGetAliases()
 210     {
 211         $builder = new ContainerBuilder();
 212         $builder->setAlias('bar', 'foo');
 213         $builder->setAlias('foobar', 'foo');
 214         $builder->setAlias('moo', new Alias('foo', false));
 215
 216         $aliases = $builder->getAliases();
 217         $this->assertEquals('foo', (string) $aliases['bar']);
 218         $this->assertTrue($aliases['bar']->isPublic());
 219         $this->assertEquals('foo', (string) $aliases['foobar']);
 220         $this->assertEquals('foo', (string) $aliases['moo']);
 221         $this->assertFalse($aliases['moo']->isPublic());
 222
 223         $builder->register('bar', 'stdClass');
 224         $this->assertFalse($builder->hasAlias('bar'));
 225
 226         $builder->set('foobar', 'stdClass');
 227         $builder->set('moo', 'stdClass');
 228         $this->assertCount(0, $builder->getAliases(), '->getAliases() does not return aliased services that have been overridden');
 229     }
 230
 231     public function testSetAliases()
 232     {
 233         $builder = new ContainerBuilder();
 234         $builder->setAliases(array('bar' => 'foo', 'foobar' => 'foo'));
 235
 236         $aliases = $builder->getAliases();
 237         $this->assertTrue(isset($aliases['bar']));
 238         $this->assertTrue(isset($aliases['foobar']));
 239     }
 240
 241     public function testAddAliases()
 242     {
 243         $builder = new ContainerBuilder();
 244         $builder->setAliases(array('bar' => 'foo'));
 245         $builder->addAliases(array('foobar' => 'foo'));
 246
 247         $aliases = $builder->getAliases();
 248         $this->assertTrue(isset($aliases['bar']));
 249         $this->assertTrue(isset($aliases['foobar']));
 250     }
 251
 252     public function testSetReplacesAlias()
 253     {
 254         $builder = new ContainerBuilder();
 255         $builder->setAlias('alias', 'aliased');
 256         $builder->set('aliased', new \stdClass());
 257
 258         $builder->set('alias', $foo = new \stdClass());
 259         $this->assertSame($foo, $builder->get('alias'), '->set() replaces an existing alias');
 260     }
 261
 262     public function testAliasesKeepInvalidBehavior()
 263     {
 264         $builder = new ContainerBuilder();
 265
 266         $aliased = new Definition('stdClass');
 267         $aliased->addMethodCall('setBar', array(new Reference('bar', ContainerInterface::IGNORE_ON_INVALID_REFERENCE)));
 268         $builder->setDefinition('aliased', $aliased);
 269         $builder->setAlias('alias', 'aliased');
 270
 271         $this->assertEquals(new \stdClass(), $builder->get('alias'));
 272     }
 273
 274     public function testAddGetCompilerPass()
 275     {
 276         $builder = new ContainerBuilder();
 277         $builder->setResourceTracking(false);
 278         $builderCompilerPasses = $builder->getCompiler()->getPassConfig()->getPasses();
 279         $builder->addCompilerPass($this->getMockBuilder('Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface')->getMock());
 280
 281         $this->assertCount(count($builder->getCompiler()->getPassConfig()->getPasses()) - 1, $builderCompilerPasses);
 282     }
 283
 284     public function testCreateService()
 285     {
 286         $builder = new ContainerBuilder();
 287         $builder->register('foo1', 'Bar\FooClass')->setFile(__DIR__.'/Fixtures/includes/foo.php');
 288         $this->assertInstanceOf('\Bar\FooClass', $builder->get('foo1'), '->createService() requires the file defined by the service definition');
 289         $builder->register('foo2', 'Bar\FooClass')->setFile(__DIR__.'/Fixtures/includes/%file%.php');
 290         $builder->setParameter('file', 'foo');
 291         $this->assertInstanceOf('\Bar\FooClass', $builder->get('foo2'), '->createService() replaces parameters in the file provided by the service definition');
 292     }
 293
 294     public function testCreateProxyWithRealServiceInstantiator()
 295     {
 296         $builder = new ContainerBuilder();
 297
 298         $builder->register('foo1', 'Bar\FooClass')->setFile(__DIR__.'/Fixtures/includes/foo.php');
 299         $builder->getDefinition('foo1')->setLazy(true);
 300
 301         $foo1 = $builder->get('foo1');
 302
 303         $this->assertSame($foo1, $builder->get('foo1'), 'The same proxy is retrieved on multiple subsequent calls');
 304         $this->assertSame('Bar\FooClass', get_class($foo1));
 305     }
 306
 307     public function testCreateServiceClass()
 308     {
 309         $builder = new ContainerBuilder();
 310         $builder->register('foo1', '%class%');
 311         $builder->setParameter('class', 'stdClass');
 312         $this->assertInstanceOf('\stdClass', $builder->get('foo1'), '->createService() replaces parameters in the class provided by the service definition');
 313     }
 314
 315     public function testCreateServiceArguments()
 316     {
 317         $builder = new ContainerBuilder();
 318         $builder->register('bar', 'stdClass');
 319         $builder->register('foo1', 'Bar\FooClass')->addArgument(array('foo' => '%value%', '%value%' => 'foo', new Reference('bar'), '%%unescape_it%%'));
 320         $builder->setParameter('value', 'bar');
 321         $this->assertEquals(array('foo' => 'bar', 'bar' => 'foo', $builder->get('bar'), '%unescape_it%'), $builder->get('foo1')->arguments, '->createService() replaces parameters and service references in the arguments provided by the service definition');
 322     }
 323
 324     public function testCreateServiceFactory()
 325     {
 326         $builder = new ContainerBuilder();
 327         $builder->register('foo', 'Bar\FooClass')->setFactory('Bar\FooClass::getInstance');
 328         $builder->register('qux', 'Bar\FooClass')->setFactory(array('Bar\FooClass', 'getInstance'));
 329         $builder->register('bar', 'Bar\FooClass')->setFactory(array(new Definition('Bar\FooClass'), 'getInstance'));
 330         $builder->register('baz', 'Bar\FooClass')->setFactory(array(new Reference('bar'), 'getInstance'));
 331
 332         $this->assertTrue($builder->get('foo')->called, '->createService() calls the factory method to create the service instance');
 333         $this->assertTrue($builder->get('qux')->called, '->createService() calls the factory method to create the service instance');
 334         $this->assertTrue($builder->get('bar')->called, '->createService() uses anonymous service as factory');
 335         $this->assertTrue($builder->get('baz')->called, '->createService() uses another service as factory');
 336     }
 337
 338     /**
 339      * @group legacy
 340      */
 341     public function testLegacyCreateServiceFactory()
 342     {
 343         $builder = new ContainerBuilder();
 344         $builder->register('bar', 'Bar\FooClass');
 345         $builder
 346             ->register('foo1', 'Bar\FooClass')
 347             ->setFactoryClass('%foo_class%')
 348             ->setFactoryMethod('getInstance')
 349             ->addArgument(array('foo' => '%value%', '%value%' => 'foo', new Reference('bar')))
 350         ;
 351         $builder->setParameter('value', 'bar');
 352         $builder->setParameter('foo_class', 'Bar\FooClass');
 353         $this->assertTrue($builder->get('foo1')->called, '->createService() calls the factory method to create the service instance');
 354         $this->assertEquals(array('foo' => 'bar', 'bar' => 'foo', $builder->get('bar')), $builder->get('foo1')->arguments, '->createService() passes the arguments to the factory method');
 355     }
 356
 357     /**
 358      * @group legacy
 359      */
 360     public function testLegacyCreateServiceFactoryService()
 361     {
 362         $builder = new ContainerBuilder();
 363         $builder->register('foo_service', 'Bar\FooClass');
 364         $builder
 365             ->register('foo', 'Bar\FooClass')
 366             ->setFactoryService('%foo_service%')
 367             ->setFactoryMethod('getInstance')
 368         ;
 369         $builder->setParameter('foo_service', 'foo_service');
 370         $this->assertTrue($builder->get('foo')->called, '->createService() calls the factory method to create the service instance');
 371     }
 372
 373     public function testCreateServiceMethodCalls()
 374     {
 375         $builder = new ContainerBuilder();
 376         $builder->register('bar', 'stdClass');
 377         $builder->register('foo1', 'Bar\FooClass')->addMethodCall('setBar', array(array('%value%', new Reference('bar'))));
 378         $builder->setParameter('value', 'bar');
 379         $this->assertEquals(array('bar', $builder->get('bar')), $builder->get('foo1')->bar, '->createService() replaces the values in the method calls arguments');
 380     }
 381
 382     public function testCreateServiceMethodCallsWithEscapedParam()
 383     {
 384         $builder = new ContainerBuilder();
 385         $builder->register('bar', 'stdClass');
 386         $builder->register('foo1', 'Bar\FooClass')->addMethodCall('setBar', array(array('%%unescape_it%%')));
 387         $builder->setParameter('value', 'bar');
 388         $this->assertEquals(array('%unescape_it%'), $builder->get('foo1')->bar, '->createService() replaces the values in the method calls arguments');
 389     }
 390
 391     public function testCreateServiceProperties()
 392     {
 393         $builder = new ContainerBuilder();
 394         $builder->register('bar', 'stdClass');
 395         $builder->register('foo1', 'Bar\FooClass')->setProperty('bar', array('%value%', new Reference('bar'), '%%unescape_it%%'));
 396         $builder->setParameter('value', 'bar');
 397         $this->assertEquals(array('bar', $builder->get('bar'), '%unescape_it%'), $builder->get('foo1')->bar, '->createService() replaces the values in the properties');
 398     }
 399
 400     public function testCreateServiceConfigurator()
 401     {
 402         $builder = new ContainerBuilder();
 403         $builder->register('foo1', 'Bar\FooClass')->setConfigurator('sc_configure');
 404         $this->assertTrue($builder->get('foo1')->configured, '->createService() calls the configurator');
 405
 406         $builder->register('foo2', 'Bar\FooClass')->setConfigurator(array('%class%', 'configureStatic'));
 407         $builder->setParameter('class', 'BazClass');
 408         $this->assertTrue($builder->get('foo2')->configured, '->createService() calls the configurator');
 409
 410         $builder->register('baz', 'BazClass');
 411         $builder->register('foo3', 'Bar\FooClass')->setConfigurator(array(new Reference('baz'), 'configure'));
 412         $this->assertTrue($builder->get('foo3')->configured, '->createService() calls the configurator');
 413
 414         $builder->register('foo4', 'Bar\FooClass')->setConfigurator(array($builder->getDefinition('baz'), 'configure'));
 415         $this->assertTrue($builder->get('foo4')->configured, '->createService() calls the configurator');
 416
 417         $builder->register('foo5', 'Bar\FooClass')->setConfigurator('foo');
 418         try {
 419             $builder->get('foo5');
 420             $this->fail('->createService() throws an InvalidArgumentException if the configure callable is not a valid callable');
 421         } catch (\InvalidArgumentException $e) {
 422             $this->assertEquals('The configure callable for class "Bar\FooClass" is not a callable.', $e->getMessage(), '->createService() throws an InvalidArgumentException if the configure callable is not a valid callable');
 423         }
 424     }
 425
 426     /**
 427      * @expectedException \RuntimeException
 428      */
 429     public function testCreateSyntheticService()
 430     {
 431         $builder = new ContainerBuilder();
 432         $builder->register('foo', 'Bar\FooClass')->setSynthetic(true);
 433         $builder->get('foo');
 434     }
 435
 436     public function testCreateServiceWithExpression()
 437     {
 438         $builder = new ContainerBuilder();
 439         $builder->setParameter('bar', 'bar');
 440         $builder->register('bar', 'BarClass');
 441         $builder->register('foo', 'Bar\FooClass')->addArgument(array('foo' => new Expression('service("bar").foo ~ parameter("bar")')));
 442         $this->assertEquals('foobar', $builder->get('foo')->arguments['foo']);
 443     }
 444
 445     public function testResolveServices()
 446     {
 447         $builder = new ContainerBuilder();
 448         $builder->register('foo', 'Bar\FooClass');
 449         $this->assertEquals($builder->get('foo'), $builder->resolveServices(new Reference('foo')), '->resolveServices() resolves service references to service instances');
 450         $this->assertEquals(array('foo' => array('foo', $builder->get('foo'))), $builder->resolveServices(array('foo' => array('foo', new Reference('foo')))), '->resolveServices() resolves service references to service instances in nested arrays');
 451         $this->assertEquals($builder->get('foo'), $builder->resolveServices(new Expression('service("foo")')), '->resolveServices() resolves expressions');
 452     }
 453
 454     /**
 455      * @expectedException \Symfony\Component\DependencyInjection\Exception\RuntimeException
 456      * @expectedExceptionMessage Constructing service "foo" from a parent definition is not supported at build time.
 457      */
 458     public function testResolveServicesWithDecoratedDefinition()
 459     {
 460         $builder = new ContainerBuilder();
 461         $builder->setDefinition('grandpa', new Definition('stdClass'));
 462         $builder->setDefinition('parent', new DefinitionDecorator('grandpa'));
 463         $builder->setDefinition('foo', new DefinitionDecorator('parent'));
 464
 465         $builder->get('foo');
 466     }
 467
 468     public function testResolveServicesWithCustomDefinitionClass()
 469     {
 470         $builder = new ContainerBuilder();
 471         $builder->setDefinition('foo', new CustomDefinition('stdClass'));
 472
 473         $this->assertInstanceOf('stdClass', $builder->get('foo'));
 474     }
 475
 476     public function testMerge()
 477     {
 478         $container = new ContainerBuilder(new ParameterBag(array('bar' => 'foo')));
 479         $container->setResourceTracking(false);
 480         $config = new ContainerBuilder(new ParameterBag(array('foo' => 'bar')));
 481         $container->merge($config);
 482         $this->assertEquals(array('bar' => 'foo', 'foo' => 'bar'), $container->getParameterBag()->all(), '->merge() merges current parameters with the loaded ones');
 483
 484         $container = new ContainerBuilder(new ParameterBag(array('bar' => 'foo')));
 485         $container->setResourceTracking(false);
 486         $config = new ContainerBuilder(new ParameterBag(array('foo' => '%bar%')));
 487         $container->merge($config);
 488         $container->compile();
 489         $this->assertEquals(array('bar' => 'foo', 'foo' => 'foo'), $container->getParameterBag()->all(), '->merge() evaluates the values of the parameters towards already defined ones');
 490
 491         $container = new ContainerBuilder(new ParameterBag(array('bar' => 'foo')));
 492         $container->setResourceTracking(false);
 493         $config = new ContainerBuilder(new ParameterBag(array('foo' => '%bar%', 'baz' => '%foo%')));
 494         $container->merge($config);
 495         $container->compile();
 496         $this->assertEquals(array('bar' => 'foo', 'foo' => 'foo', 'baz' => 'foo'), $container->getParameterBag()->all(), '->merge() evaluates the values of the parameters towards already defined ones');
 497
 498         $container = new ContainerBuilder();
 499         $container->setResourceTracking(false);
 500         $container->register('foo', 'Bar\FooClass');
 501         $container->register('bar', 'BarClass');
 502         $config = new ContainerBuilder();
 503         $config->setDefinition('baz', new Definition('BazClass'));
 504         $config->setAlias('alias_for_foo', 'foo');
 505         $container->merge($config);
 506         $this->assertEquals(array('foo', 'bar', 'baz'), array_keys($container->getDefinitions()), '->merge() merges definitions already defined ones');
 507
 508         $aliases = $container->getAliases();
 509         $this->assertTrue(isset($aliases['alias_for_foo']));
 510         $this->assertEquals('foo', (string) $aliases['alias_for_foo']);
 511
 512         $container = new ContainerBuilder();
 513         $container->setResourceTracking(false);
 514         $container->register('foo', 'Bar\FooClass');
 515         $config->setDefinition('foo', new Definition('BazClass'));
 516         $container->merge($config);
 517         $this->assertEquals('BazClass', $container->getDefinition('foo')->getClass(), '->merge() overrides already defined services');
 518     }
 519
 520     /**
 521      * @expectedException \LogicException
 522      */
 523     public function testMergeLogicException()
 524     {
 525         $container = new ContainerBuilder();
 526         $container->setResourceTracking(false);
 527         $container->compile();
 528         $container->merge(new ContainerBuilder());
 529     }
 530
 531     public function testfindTaggedServiceIds()
 532     {
 533         $builder = new ContainerBuilder();
 534         $builder
 535             ->register('foo', 'Bar\FooClass')
 536             ->addTag('foo', array('foo' => 'foo'))
 537             ->addTag('bar', array('bar' => 'bar'))
 538             ->addTag('foo', array('foofoo' => 'foofoo'))
 539         ;
 540         $this->assertEquals($builder->findTaggedServiceIds('foo'), array(
 541             'foo' => array(
 542                 array('foo' => 'foo'),
 543                 array('foofoo' => 'foofoo'),
 544             ),
 545         ), '->findTaggedServiceIds() returns an array of service ids and its tag attributes');
 546         $this->assertEquals(array(), $builder->findTaggedServiceIds('foobar'), '->findTaggedServiceIds() returns an empty array if there is annotated services');
 547     }
 548
 549     public function testFindUnusedTags()
 550     {
 551         $builder = new ContainerBuilder();
 552         $builder
 553             ->register('foo', 'Bar\FooClass')
 554             ->addTag('kernel.event_listener', array('foo' => 'foo'))
 555             ->addTag('kenrel.event_listener', array('bar' => 'bar'))
 556         ;
 557         $builder->findTaggedServiceIds('kernel.event_listener');
 558         $this->assertEquals(array('kenrel.event_listener'), $builder->findUnusedTags(), '->findUnusedTags() returns an array with unused tags');
 559     }
 560
 561     public function testFindDefinition()
 562     {
 563         $container = new ContainerBuilder();
 564         $container->setDefinition('foo', $definition = new Definition('Bar\FooClass'));
 565         $container->setAlias('bar', 'foo');
 566         $container->setAlias('foobar', 'bar');
 567         $this->assertEquals($definition, $container->findDefinition('foobar'), '->findDefinition() returns a Definition');
 568     }
 569
 570     public function testAddObjectResource()
 571     {
 572         $container = new ContainerBuilder();
 573
 574         $container->setResourceTracking(false);
 575         $container->addObjectResource(new \BarClass());
 576
 577         $this->assertEmpty($container->getResources(), 'No resources get registered without resource tracking');
 578
 579         $container->setResourceTracking(true);
 580         $container->addObjectResource(new \BarClass());
 581
 582         $resources = $container->getResources();
 583
 584         $this->assertCount(1, $resources, '1 resource was registered');
 585
 586         /* @var $resource \Symfony\Component\Config\Resource\FileResource */
 587         $resource = end($resources);
 588
 589         $this->assertInstanceOf('Symfony\Component\Config\Resource\FileResource', $resource);
 590         $this->assertSame(realpath(__DIR__.'/Fixtures/includes/classes.php'), realpath($resource->getResource()));
 591     }
 592
 593     public function testAddClassResource()
 594     {
 595         $container = new ContainerBuilder();
 596
 597         $container->setResourceTracking(false);
 598         $container->addClassResource(new \ReflectionClass('BarClass'));
 599
 600         $this->assertEmpty($container->getResources(), 'No resources get registered without resource tracking');
 601
 602         $container->setResourceTracking(true);
 603         $container->addClassResource(new \ReflectionClass('BarClass'));
 604
 605         $resources = $container->getResources();
 606
 607         $this->assertCount(1, $resources, '1 resource was registered');
 608
 609         /* @var $resource \Symfony\Component\Config\Resource\FileResource */
 610         $resource = end($resources);
 611
 612         $this->assertInstanceOf('Symfony\Component\Config\Resource\FileResource', $resource);
 613         $this->assertSame(realpath(__DIR__.'/Fixtures/includes/classes.php'), realpath($resource->getResource()));
 614     }
 615
 616     public function testCompilesClassDefinitionsOfLazyServices()
 617     {
 618         $container = new ContainerBuilder();
 619
 620         $this->assertEmpty($container->getResources(), 'No resources get registered without resource tracking');
 621
 622         $container->register('foo', 'BarClass');
 623         $container->getDefinition('foo')->setLazy(true);
 624
 625         $container->compile();
 626
 627         $classesPath = realpath(__DIR__.'/Fixtures/includes/classes.php');
 628         $matchingResources = array_filter(
 629             $container->getResources(),
 630             function (ResourceInterface $resource) use ($classesPath) {
 631                 return $resource instanceof FileResource && $classesPath === realpath($resource->getResource());
 632             }
 633         );
 634
 635         $this->assertNotEmpty($matchingResources);
 636     }
 637
 638     public function testResources()
 639     {
 640         $container = new ContainerBuilder();
 641         $container->addResource($a = new FileResource(__DIR__.'/Fixtures/xml/services1.xml'));
 642         $container->addResource($b = new FileResource(__DIR__.'/Fixtures/xml/services2.xml'));
 643         $resources = array();
 644         foreach ($container->getResources() as $resource) {
 645             if (false === strpos($resource, '.php')) {
 646                 $resources[] = $resource;
 647             }
 648         }
 649         $this->assertEquals(array($a, $b), $resources, '->getResources() returns an array of resources read for the current configuration');
 650         $this->assertSame($container, $container->setResources(array()));
 651         $this->assertEquals(array(), $container->getResources());
 652     }
 653
 654     public function testExtension()
 655     {
 656         $container = new ContainerBuilder();
 657         $container->setResourceTracking(false);
 658
 659         $container->registerExtension($extension = new \ProjectExtension());
 660         $this->assertTrue($container->getExtension('project') === $extension, '->registerExtension() registers an extension');
 661
 662         $this->{method_exists($this, $_ = 'expectException') ? $_ : 'setExpectedException'}('LogicException');
 663         $container->getExtension('no_registered');
 664     }
 665
 666     public function testRegisteredButNotLoadedExtension()
 667     {
 668         $extension = $this->getMockBuilder('Symfony\\Component\\DependencyInjection\\Extension\\ExtensionInterface')->getMock();
 669         $extension->expects($this->once())->method('getAlias')->will($this->returnValue('project'));
 670         $extension->expects($this->never())->method('load');
 671
 672         $container = new ContainerBuilder();
 673         $container->setResourceTracking(false);
 674         $container->registerExtension($extension);
 675         $container->compile();
 676     }
 677
 678     public function testRegisteredAndLoadedExtension()
 679     {
 680         $extension = $this->getMockBuilder('Symfony\\Component\\DependencyInjection\\Extension\\ExtensionInterface')->getMock();
 681         $extension->expects($this->exactly(2))->method('getAlias')->will($this->returnValue('project'));
 682         $extension->expects($this->once())->method('load')->with(array(array('foo' => 'bar')));
 683
 684         $container = new ContainerBuilder();
 685         $container->setResourceTracking(false);
 686         $container->registerExtension($extension);
 687         $container->loadFromExtension('project', array('foo' => 'bar'));
 688         $container->compile();
 689     }
 690
 691     public function testPrivateServiceUser()
 692     {
 693         $fooDefinition = new Definition('BarClass');
 694         $fooUserDefinition = new Definition('BarUserClass', array(new Reference('bar')));
 695         $container = new ContainerBuilder();
 696         $container->setResourceTracking(false);
 697
 698         $fooDefinition->setPublic(false);
 699
 700         $container->addDefinitions(array(
 701             'bar' => $fooDefinition,
 702             'bar_user' => $fooUserDefinition,
 703         ));
 704
 705         $container->compile();
 706         $this->assertInstanceOf('BarClass', $container->get('bar_user')->bar);
 707     }
 708
 709     /**
 710      * @expectedException \BadMethodCallException
 711      */
 712     public function testThrowsExceptionWhenSetServiceOnAFrozenContainer()
 713     {
 714         $container = new ContainerBuilder();
 715         $container->setResourceTracking(false);
 716         $container->setDefinition('a', new Definition('stdClass'));
 717         $container->compile();
 718         $container->set('a', new \stdClass());
 719     }
 720
 721     public function testThrowsExceptionWhenAddServiceOnAFrozenContainer()
 722     {
 723         $container = new ContainerBuilder();
 724         $container->compile();
 725         $container->set('a', $foo = new \stdClass());
 726         $this->assertSame($foo, $container->get('a'));
 727     }
 728
 729     public function testNoExceptionWhenSetSyntheticServiceOnAFrozenContainer()
 730     {
 731         $container = new ContainerBuilder();
 732         $def = new Definition('stdClass');
 733         $def->setSynthetic(true);
 734         $container->setDefinition('a', $def);
 735         $container->compile();
 736         $container->set('a', $a = new \stdClass());
 737         $this->assertEquals($a, $container->get('a'));
 738     }
 739
 740     /**
 741      * @group legacy
 742      */
 743     public function testLegacySetOnSynchronizedService()
 744     {
 745         $container = new ContainerBuilder();
 746         $container->register('baz', 'BazClass')
 747             ->setSynchronized(true)
 748         ;
 749         $container->register('bar', 'BarClass')
 750             ->addMethodCall('setBaz', array(new Reference('baz')))
 751         ;
 752
 753         $container->set('baz', $baz = new \BazClass());
 754         $this->assertSame($baz, $container->get('bar')->getBaz());
 755
 756         $container->set('baz', $baz = new \BazClass());
 757         $this->assertSame($baz, $container->get('bar')->getBaz());
 758     }
 759
 760     /**
 761      * @group legacy
 762      */
 763     public function testLegacySynchronizedServiceWithScopes()
 764     {
 765         $container = new ContainerBuilder();
 766         $container->addScope(new Scope('foo'));
 767         $container->register('baz', 'BazClass')
 768             ->setSynthetic(true)
 769             ->setSynchronized(true)
 770             ->setScope('foo')
 771         ;
 772         $container->register('bar', 'BarClass')
 773             ->addMethodCall('setBaz', array(new Reference('baz', ContainerInterface::NULL_ON_INVALID_REFERENCE, false)))
 774         ;
 775         $container->compile();
 776
 777         $container->enterScope('foo');
 778         $container->set('baz', $outerBaz = new \BazClass(), 'foo');
 779         $this->assertSame($outerBaz, $container->get('bar')->getBaz());
 780
 781         $container->enterScope('foo');
 782         $container->set('baz', $innerBaz = new \BazClass(), 'foo');
 783         $this->assertSame($innerBaz, $container->get('bar')->getBaz());
 784         $container->leaveScope('foo');
 785
 786         $this->assertNotSame($innerBaz, $container->get('bar')->getBaz());
 787         $this->assertSame($outerBaz, $container->get('bar')->getBaz());
 788
 789         $container->leaveScope('foo');
 790     }
 791
 792     /**
 793      * @expectedException \BadMethodCallException
 794      */
 795     public function testThrowsExceptionWhenSetDefinitionOnAFrozenContainer()
 796     {
 797         $container = new ContainerBuilder();
 798         $container->setResourceTracking(false);
 799         $container->compile();
 800         $container->setDefinition('a', new Definition());
 801     }
 802
 803     public function testExtensionConfig()
 804     {
 805         $container = new ContainerBuilder();
 806
 807         $configs = $container->getExtensionConfig('foo');
 808         $this->assertEmpty($configs);
 809
 810         $first = array('foo' => 'bar');
 811         $container->prependExtensionConfig('foo', $first);
 812         $configs = $container->getExtensionConfig('foo');
 813         $this->assertEquals(array($first), $configs);
 814
 815         $second = array('ding' => 'dong');
 816         $container->prependExtensionConfig('foo', $second);
 817         $configs = $container->getExtensionConfig('foo');
 818         $this->assertEquals(array($second, $first), $configs);
 819     }
 820
 821     public function testAbstractAlias()
 822     {
 823         $container = new ContainerBuilder();
 824
 825         $abstract = new Definition('AbstractClass');
 826         $abstract->setAbstract(true);
 827
 828         $container->setDefinition('abstract_service', $abstract);
 829         $container->setAlias('abstract_alias', 'abstract_service');
 830
 831         $container->compile();
 832
 833         $this->assertSame('abstract_service', (string) $container->getAlias('abstract_alias'));
 834     }
 835
 836     public function testLazyLoadedService()
 837     {
 838         $loader = new ClosureLoader($container = new ContainerBuilder());
 839         $loader->load(function (ContainerBuilder $container) {
 840             $container->set('a', new \BazClass());
 841             $definition = new Definition('BazClass');
 842             $definition->setLazy(true);
 843             $container->setDefinition('a', $definition);
 844         });
 845
 846         $container->setResourceTracking(true);
 847
 848         $container->compile();
 849
 850         $class = new \BazClass();
 851         $reflectionClass = new \ReflectionClass($class);
 852
 853         $r = new \ReflectionProperty($container, 'resources');
 854         $r->setAccessible(true);
 855         $resources = $r->getValue($container);
 856
 857         $classInList = false;
 858         foreach ($resources as $resource) {
 859             if ($resource->getResource() === $reflectionClass->getFileName()) {
 860                 $classInList = true;
 861                 break;
 862             }
 863         }
 864
 865         $this->assertTrue($classInList);
 866     }
 867
 868     public function testInitializePropertiesBeforeMethodCalls()
 869     {
 870         $container = new ContainerBuilder();
 871         $container->register('foo', 'stdClass');
 872         $container->register('bar', 'MethodCallClass')
 873             ->setProperty('simple', 'bar')
 874             ->setProperty('complex', new Reference('foo'))
 875             ->addMethodCall('callMe');
 876
 877         $container->compile();
 878
 879         $this->assertTrue($container->get('bar')->callPassed(), '->compile() initializes properties before method calls');
 880     }
 881
 882     public function testAutowiring()
 883     {
 884         $container = new ContainerBuilder();
 885
 886         $container->register('a', __NAMESPACE__.'\A');
 887         $bDefinition = $container->register('b', __NAMESPACE__.'\B');
 888         $bDefinition->setAutowired(true);
 889
 890         $container->compile();
 891
 892         $this->assertEquals('a', (string) $container->getDefinition('b')->getArgument(0));
 893     }
 894 }
 895
 896 class FooClass
 897 {
 898 }
 899
 900 class ProjectContainer extends ContainerBuilder
 901 {
 902     public function getFoobazService()
 903     {
 904         throw new InactiveScopeException('foo', 'request');
 905     }
 906 }
 907
 908 class A
 909 {
 910 }
 911
 912 class B
 913 {
 914     public function __construct(A $a)
 915     {
 916     }
 917 }