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