4 * This file is part of the Symfony package.
6 * (c) Fabien Potencier <fabien@symfony.com>
8 * For the full copyright and license information, please view the LICENSE
9 * file that was distributed with this source code.
12 namespace Symfony\Component\DependencyInjection\Tests;
14 require_once __DIR__.'/Fixtures/includes/classes.php';
15 require_once __DIR__.'/Fixtures/includes/ProjectExtension.php';
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;
36 class ContainerBuilderTest extends TestCase
38 public function testDefinitions()
40 $builder = new ContainerBuilder();
42 'foo' => new Definition('Bar\FooClass'),
43 'bar' => new Definition('BarClass'),
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');
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');
54 $builder->addDefinitions($defs = array('foobar' => new Definition('FooBarClass')));
55 $this->assertEquals(array_merge($definitions, $defs), $builder->getDefinitions(), '->addDefinitions() adds the service definitions');
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');
67 * @expectedDeprecation The "deprecated_foo" service is deprecated. You should stop using it, as it will soon be removed.
69 public function testCreateDeprecatedService()
71 $definition = new Definition('stdClass');
72 $definition->setDeprecated(true);
74 $builder = new ContainerBuilder();
75 $builder->createService($definition, 'deprecated_foo');
78 public function testRegister()
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');
86 public function testHas()
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');
96 public function testGet()
98 $builder = new ContainerBuilder();
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');
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');
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');
115 $builder->register('baz', 'stdClass')->setArguments(array(new Reference('baz')));
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');
123 $this->assertTrue($builder->get('bar') === $builder->get('bar'), '->get() always returns the same instance if the service is shared');
126 public function testNonSharedServicesReturnsDifferentInstances()
128 $builder = new ContainerBuilder();
129 $builder->register('bar', 'stdClass')->setShared(false);
131 $this->assertNotSame($builder->get('bar'), $builder->get('bar'));
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.
138 public function testGetUnsetLoadingServiceWhenCreateServiceThrowsAnException()
140 $builder = new ContainerBuilder();
141 $builder->register('foo', 'stdClass')->setSynthetic(true);
143 // we expect a RuntimeException here as foo is synthetic
145 $builder->get('foo');
146 } catch (RuntimeException $e) {
149 // we must also have the same RuntimeException here
150 $builder->get('foo');
156 public function testGetReturnsNullOnInactiveScope()
158 $builder = new ContainerBuilder();
159 $builder->register('foo', 'stdClass')->setScope('request');
161 $this->assertNull($builder->get('foo', ContainerInterface::NULL_ON_INVALID_REFERENCE));
167 public function testGetReturnsNullOnInactiveScopeWhenServiceIsCreatedByAMethod()
169 $builder = new ProjectContainer();
171 $this->assertNull($builder->get('foobaz', ContainerInterface::NULL_ON_INVALID_REFERENCE));
174 public function testGetServiceIds()
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');
183 public function testAliases()
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');
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');
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');
209 public function testGetAliases()
211 $builder = new ContainerBuilder();
212 $builder->setAlias('bar', 'foo');
213 $builder->setAlias('foobar', 'foo');
214 $builder->setAlias('moo', new Alias('foo', false));
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());
223 $builder->register('bar', 'stdClass');
224 $this->assertFalse($builder->hasAlias('bar'));
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');
231 public function testSetAliases()
233 $builder = new ContainerBuilder();
234 $builder->setAliases(array('bar' => 'foo', 'foobar' => 'foo'));
236 $aliases = $builder->getAliases();
237 $this->assertTrue(isset($aliases['bar']));
238 $this->assertTrue(isset($aliases['foobar']));
241 public function testAddAliases()
243 $builder = new ContainerBuilder();
244 $builder->setAliases(array('bar' => 'foo'));
245 $builder->addAliases(array('foobar' => 'foo'));
247 $aliases = $builder->getAliases();
248 $this->assertTrue(isset($aliases['bar']));
249 $this->assertTrue(isset($aliases['foobar']));
252 public function testSetReplacesAlias()
254 $builder = new ContainerBuilder();
255 $builder->setAlias('alias', 'aliased');
256 $builder->set('aliased', new \stdClass());
258 $builder->set('alias', $foo = new \stdClass());
259 $this->assertSame($foo, $builder->get('alias'), '->set() replaces an existing alias');
262 public function testAliasesKeepInvalidBehavior()
264 $builder = new ContainerBuilder();
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');
271 $this->assertEquals(new \stdClass(), $builder->get('alias'));
274 public function testAddGetCompilerPass()
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());
281 $this->assertCount(count($builder->getCompiler()->getPassConfig()->getPasses()) - 1, $builderCompilerPasses);
284 public function testCreateService()
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');
294 public function testCreateProxyWithRealServiceInstantiator()
296 $builder = new ContainerBuilder();
298 $builder->register('foo1', 'Bar\FooClass')->setFile(__DIR__.'/Fixtures/includes/foo.php');
299 $builder->getDefinition('foo1')->setLazy(true);
301 $foo1 = $builder->get('foo1');
303 $this->assertSame($foo1, $builder->get('foo1'), 'The same proxy is retrieved on multiple subsequent calls');
304 $this->assertSame('Bar\FooClass', get_class($foo1));
307 public function testCreateServiceClass()
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');
315 public function testCreateServiceArguments()
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');
324 public function testCreateServiceFactory()
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'));
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');
341 public function testLegacyCreateServiceFactory()
343 $builder = new ContainerBuilder();
344 $builder->register('bar', 'Bar\FooClass');
346 ->register('foo1', 'Bar\FooClass')
347 ->setFactoryClass('%foo_class%')
348 ->setFactoryMethod('getInstance')
349 ->addArgument(array('foo' => '%value%', '%value%' => 'foo', new Reference('bar')))
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');
360 public function testLegacyCreateServiceFactoryService()
362 $builder = new ContainerBuilder();
363 $builder->register('foo_service', 'Bar\FooClass');
365 ->register('foo', 'Bar\FooClass')
366 ->setFactoryService('%foo_service%')
367 ->setFactoryMethod('getInstance')
369 $builder->setParameter('foo_service', 'foo_service');
370 $this->assertTrue($builder->get('foo')->called, '->createService() calls the factory method to create the service instance');
373 public function testCreateServiceMethodCalls()
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');
382 public function testCreateServiceMethodCallsWithEscapedParam()
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');
391 public function testCreateServiceProperties()
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');
400 public function testCreateServiceConfigurator()
402 $builder = new ContainerBuilder();
403 $builder->register('foo1', 'Bar\FooClass')->setConfigurator('sc_configure');
404 $this->assertTrue($builder->get('foo1')->configured, '->createService() calls the configurator');
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');
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');
414 $builder->register('foo4', 'Bar\FooClass')->setConfigurator(array($builder->getDefinition('baz'), 'configure'));
415 $this->assertTrue($builder->get('foo4')->configured, '->createService() calls the configurator');
417 $builder->register('foo5', 'Bar\FooClass')->setConfigurator('foo');
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');
427 * @expectedException \RuntimeException
429 public function testCreateSyntheticService()
431 $builder = new ContainerBuilder();
432 $builder->register('foo', 'Bar\FooClass')->setSynthetic(true);
433 $builder->get('foo');
436 public function testCreateServiceWithExpression()
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']);
445 public function testResolveServices()
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');
455 * @expectedException \Symfony\Component\DependencyInjection\Exception\RuntimeException
456 * @expectedExceptionMessage Constructing service "foo" from a parent definition is not supported at build time.
458 public function testResolveServicesWithDecoratedDefinition()
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'));
465 $builder->get('foo');
468 public function testResolveServicesWithCustomDefinitionClass()
470 $builder = new ContainerBuilder();
471 $builder->setDefinition('foo', new CustomDefinition('stdClass'));
473 $this->assertInstanceOf('stdClass', $builder->get('foo'));
476 public function testMerge()
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');
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');
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');
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');
508 $aliases = $container->getAliases();
509 $this->assertTrue(isset($aliases['alias_for_foo']));
510 $this->assertEquals('foo', (string) $aliases['alias_for_foo']);
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');
521 * @expectedException \LogicException
523 public function testMergeLogicException()
525 $container = new ContainerBuilder();
526 $container->setResourceTracking(false);
527 $container->compile();
528 $container->merge(new ContainerBuilder());
531 public function testfindTaggedServiceIds()
533 $builder = new ContainerBuilder();
535 ->register('foo', 'Bar\FooClass')
536 ->addTag('foo', array('foo' => 'foo'))
537 ->addTag('bar', array('bar' => 'bar'))
538 ->addTag('foo', array('foofoo' => 'foofoo'))
540 $this->assertEquals($builder->findTaggedServiceIds('foo'), array(
542 array('foo' => 'foo'),
543 array('foofoo' => 'foofoo'),
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');
549 public function testFindUnusedTags()
551 $builder = new ContainerBuilder();
553 ->register('foo', 'Bar\FooClass')
554 ->addTag('kernel.event_listener', array('foo' => 'foo'))
555 ->addTag('kenrel.event_listener', array('bar' => 'bar'))
557 $builder->findTaggedServiceIds('kernel.event_listener');
558 $this->assertEquals(array('kenrel.event_listener'), $builder->findUnusedTags(), '->findUnusedTags() returns an array with unused tags');
561 public function testFindDefinition()
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');
570 public function testAddObjectResource()
572 $container = new ContainerBuilder();
574 $container->setResourceTracking(false);
575 $container->addObjectResource(new \BarClass());
577 $this->assertEmpty($container->getResources(), 'No resources get registered without resource tracking');
579 $container->setResourceTracking(true);
580 $container->addObjectResource(new \BarClass());
582 $resources = $container->getResources();
584 $this->assertCount(1, $resources, '1 resource was registered');
586 /* @var $resource \Symfony\Component\Config\Resource\FileResource */
587 $resource = end($resources);
589 $this->assertInstanceOf('Symfony\Component\Config\Resource\FileResource', $resource);
590 $this->assertSame(realpath(__DIR__.'/Fixtures/includes/classes.php'), realpath($resource->getResource()));
593 public function testAddClassResource()
595 $container = new ContainerBuilder();
597 $container->setResourceTracking(false);
598 $container->addClassResource(new \ReflectionClass('BarClass'));
600 $this->assertEmpty($container->getResources(), 'No resources get registered without resource tracking');
602 $container->setResourceTracking(true);
603 $container->addClassResource(new \ReflectionClass('BarClass'));
605 $resources = $container->getResources();
607 $this->assertCount(1, $resources, '1 resource was registered');
609 /* @var $resource \Symfony\Component\Config\Resource\FileResource */
610 $resource = end($resources);
612 $this->assertInstanceOf('Symfony\Component\Config\Resource\FileResource', $resource);
613 $this->assertSame(realpath(__DIR__.'/Fixtures/includes/classes.php'), realpath($resource->getResource()));
616 public function testCompilesClassDefinitionsOfLazyServices()
618 $container = new ContainerBuilder();
620 $this->assertEmpty($container->getResources(), 'No resources get registered without resource tracking');
622 $container->register('foo', 'BarClass');
623 $container->getDefinition('foo')->setLazy(true);
625 $container->compile();
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());
635 $this->assertNotEmpty($matchingResources);
638 public function testResources()
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;
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());
654 public function testExtension()
656 $container = new ContainerBuilder();
657 $container->setResourceTracking(false);
659 $container->registerExtension($extension = new \ProjectExtension());
660 $this->assertTrue($container->getExtension('project') === $extension, '->registerExtension() registers an extension');
662 $this->{method_exists($this, $_ = 'expectException') ? $_ : 'setExpectedException'}('LogicException');
663 $container->getExtension('no_registered');
666 public function testRegisteredButNotLoadedExtension()
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');
672 $container = new ContainerBuilder();
673 $container->setResourceTracking(false);
674 $container->registerExtension($extension);
675 $container->compile();
678 public function testRegisteredAndLoadedExtension()
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')));
684 $container = new ContainerBuilder();
685 $container->setResourceTracking(false);
686 $container->registerExtension($extension);
687 $container->loadFromExtension('project', array('foo' => 'bar'));
688 $container->compile();
691 public function testPrivateServiceUser()
693 $fooDefinition = new Definition('BarClass');
694 $fooUserDefinition = new Definition('BarUserClass', array(new Reference('bar')));
695 $container = new ContainerBuilder();
696 $container->setResourceTracking(false);
698 $fooDefinition->setPublic(false);
700 $container->addDefinitions(array(
701 'bar' => $fooDefinition,
702 'bar_user' => $fooUserDefinition,
705 $container->compile();
706 $this->assertInstanceOf('BarClass', $container->get('bar_user')->bar);
710 * @expectedException \BadMethodCallException
712 public function testThrowsExceptionWhenSetServiceOnAFrozenContainer()
714 $container = new ContainerBuilder();
715 $container->setResourceTracking(false);
716 $container->setDefinition('a', new Definition('stdClass'));
717 $container->compile();
718 $container->set('a', new \stdClass());
721 public function testThrowsExceptionWhenAddServiceOnAFrozenContainer()
723 $container = new ContainerBuilder();
724 $container->compile();
725 $container->set('a', $foo = new \stdClass());
726 $this->assertSame($foo, $container->get('a'));
729 public function testNoExceptionWhenSetSyntheticServiceOnAFrozenContainer()
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'));
743 public function testLegacySetOnSynchronizedService()
745 $container = new ContainerBuilder();
746 $container->register('baz', 'BazClass')
747 ->setSynchronized(true)
749 $container->register('bar', 'BarClass')
750 ->addMethodCall('setBaz', array(new Reference('baz')))
753 $container->set('baz', $baz = new \BazClass());
754 $this->assertSame($baz, $container->get('bar')->getBaz());
756 $container->set('baz', $baz = new \BazClass());
757 $this->assertSame($baz, $container->get('bar')->getBaz());
763 public function testLegacySynchronizedServiceWithScopes()
765 $container = new ContainerBuilder();
766 $container->addScope(new Scope('foo'));
767 $container->register('baz', 'BazClass')
769 ->setSynchronized(true)
772 $container->register('bar', 'BarClass')
773 ->addMethodCall('setBaz', array(new Reference('baz', ContainerInterface::NULL_ON_INVALID_REFERENCE, false)))
775 $container->compile();
777 $container->enterScope('foo');
778 $container->set('baz', $outerBaz = new \BazClass(), 'foo');
779 $this->assertSame($outerBaz, $container->get('bar')->getBaz());
781 $container->enterScope('foo');
782 $container->set('baz', $innerBaz = new \BazClass(), 'foo');
783 $this->assertSame($innerBaz, $container->get('bar')->getBaz());
784 $container->leaveScope('foo');
786 $this->assertNotSame($innerBaz, $container->get('bar')->getBaz());
787 $this->assertSame($outerBaz, $container->get('bar')->getBaz());
789 $container->leaveScope('foo');
793 * @expectedException \BadMethodCallException
795 public function testThrowsExceptionWhenSetDefinitionOnAFrozenContainer()
797 $container = new ContainerBuilder();
798 $container->setResourceTracking(false);
799 $container->compile();
800 $container->setDefinition('a', new Definition());
803 public function testExtensionConfig()
805 $container = new ContainerBuilder();
807 $configs = $container->getExtensionConfig('foo');
808 $this->assertEmpty($configs);
810 $first = array('foo' => 'bar');
811 $container->prependExtensionConfig('foo', $first);
812 $configs = $container->getExtensionConfig('foo');
813 $this->assertEquals(array($first), $configs);
815 $second = array('ding' => 'dong');
816 $container->prependExtensionConfig('foo', $second);
817 $configs = $container->getExtensionConfig('foo');
818 $this->assertEquals(array($second, $first), $configs);
821 public function testAbstractAlias()
823 $container = new ContainerBuilder();
825 $abstract = new Definition('AbstractClass');
826 $abstract->setAbstract(true);
828 $container->setDefinition('abstract_service', $abstract);
829 $container->setAlias('abstract_alias', 'abstract_service');
831 $container->compile();
833 $this->assertSame('abstract_service', (string) $container->getAlias('abstract_alias'));
836 public function testLazyLoadedService()
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);
846 $container->setResourceTracking(true);
848 $container->compile();
850 $class = new \BazClass();
851 $reflectionClass = new \ReflectionClass($class);
853 $r = new \ReflectionProperty($container, 'resources');
854 $r->setAccessible(true);
855 $resources = $r->getValue($container);
857 $classInList = false;
858 foreach ($resources as $resource) {
859 if ($resource->getResource() === $reflectionClass->getFileName()) {
865 $this->assertTrue($classInList);
868 public function testInitializePropertiesBeforeMethodCalls()
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');
877 $container->compile();
879 $this->assertTrue($container->get('bar')->callPassed(), '->compile() initializes properties before method calls');
882 public function testAutowiring()
884 $container = new ContainerBuilder();
886 $container->register('a', __NAMESPACE__.'\A');
887 $bDefinition = $container->register('b', __NAMESPACE__.'\B');
888 $bDefinition->setAutowired(true);
890 $container->compile();
892 $this->assertEquals('a', (string) $container->getDefinition('b')->getArgument(0));
900 class ProjectContainer extends ContainerBuilder
902 public function getFoobazService()
904 throw new InactiveScopeException('foo', 'request');
914 public function __construct(A $a)