2010-03-18 07:48:03 +00:00
< ? php
/*
2010-04-25 16:06:54 +01:00
* This file is part of the Symfony package .
2011-01-15 13:29:43 +00:00
*
2011-03-06 11:40:06 +00:00
* ( c ) Fabien Potencier < fabien @ symfony . com >
2010-04-07 02:07:59 +01:00
*
2010-03-18 07:48:03 +00:00
* For the full copyright and license information , please view the LICENSE
* file that was distributed with this source code .
*/
2012-03-28 14:43:52 +01:00
namespace Symfony\Component\DependencyInjection\Tests ;
require_once __DIR__ . '/Fixtures/includes/classes.php' ;
require_once __DIR__ . '/Fixtures/includes/ProjectExtension.php' ;
2010-03-18 07:48:03 +00:00
2017-02-08 07:24:27 +00:00
use PHPUnit\Framework\TestCase ;
2013-03-29 23:21:12 +00:00
use Symfony\Component\Config\Resource\ResourceInterface ;
2011-01-07 14:44:29 +00:00
use Symfony\Component\DependencyInjection\Alias ;
2010-08-20 22:09:55 +01:00
use Symfony\Component\DependencyInjection\ContainerBuilder ;
use Symfony\Component\DependencyInjection\ContainerInterface ;
use Symfony\Component\DependencyInjection\Definition ;
2016-11-17 00:37:44 +00:00
use Symfony\Component\DependencyInjection\DefinitionDecorator ;
2013-03-06 16:38:10 +00:00
use Symfony\Component\DependencyInjection\Exception\RuntimeException ;
2014-03-27 14:19:35 +00:00
use Symfony\Component\DependencyInjection\Exception\InactiveScopeException ;
2016-02-07 18:10:24 +00:00
use Symfony\Component\DependencyInjection\Exception\ServiceCircularReferenceException ;
use Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException ;
2013-11-09 11:47:52 +00:00
use Symfony\Component\DependencyInjection\Loader\ClosureLoader ;
2010-08-20 22:09:55 +01:00
use Symfony\Component\DependencyInjection\Reference ;
use Symfony\Component\DependencyInjection\ParameterBag\ParameterBag ;
2013-02-06 20:42:01 +00:00
use Symfony\Component\DependencyInjection\Scope ;
2011-02-10 15:15:51 +00:00
use Symfony\Component\Config\Resource\FileResource ;
2016-11-23 17:45:56 +00:00
use Symfony\Component\DependencyInjection\Tests\Fixtures\CustomDefinition ;
2013-09-02 11:46:47 +01:00
use Symfony\Component\ExpressionLanguage\Expression ;
2010-03-18 07:48:03 +00:00
2017-02-08 07:24:27 +00:00
class ContainerBuilderTest extends TestCase
2010-03-18 07:48:03 +00:00
{
2010-05-06 12:25:53 +01:00
public function testDefinitions ()
2010-03-18 07:48:03 +00:00
{
2010-07-15 14:11:33 +01:00
$builder = new ContainerBuilder ();
2010-05-06 12:25:53 +01:00
$definitions = array (
2013-12-18 17:52:54 +00:00
'foo' => new Definition ( 'Bar\FooClass' ),
2010-05-06 12:25:53 +01:00
'bar' => new Definition ( 'BarClass' ),
);
$builder -> setDefinitions ( $definitions );
$this -> assertEquals ( $definitions , $builder -> getDefinitions (), '->setDefinitions() sets the service definitions' );
$this -> assertTrue ( $builder -> hasDefinition ( 'foo' ), '->hasDefinition() returns true if a service definition exists' );
$this -> assertFalse ( $builder -> hasDefinition ( 'foobar' ), '->hasDefinition() returns false if a service definition does not exist' );
$builder -> setDefinition ( 'foobar' , $foo = new Definition ( 'FooBarClass' ));
$this -> assertEquals ( $foo , $builder -> getDefinition ( 'foobar' ), '->getDefinition() returns a service definition if defined' );
2011-03-01 17:56:35 +00:00
$this -> assertTrue ( $builder -> setDefinition ( 'foobar' , $foo = new Definition ( 'FooBarClass' )) === $foo , '->setDefinition() implements a fluid interface by returning the service reference' );
2010-05-06 12:25:53 +01:00
$builder -> addDefinitions ( $defs = array ( 'foobar' => new Definition ( 'FooBarClass' )));
$this -> assertEquals ( array_merge ( $definitions , $defs ), $builder -> getDefinitions (), '->addDefinitions() adds the service definitions' );
2010-05-07 15:09:11 +01:00
try {
2010-05-06 12:25:53 +01:00
$builder -> getDefinition ( 'baz' );
2016-02-07 18:10:24 +00:00
$this -> fail ( '->getDefinition() throws a ServiceNotFoundException if the service definition does not exist' );
} catch ( ServiceNotFoundException $e ) {
$this -> assertEquals ( 'You have requested a non-existent service "baz".' , $e -> getMessage (), '->getDefinition() throws a ServiceNotFoundException if the service definition does not exist' );
2010-05-06 12:25:53 +01:00
}
2010-03-18 07:48:03 +00:00
}
2010-05-06 12:25:53 +01:00
public function testRegister ()
2010-03-18 07:48:03 +00:00
{
2010-07-15 14:11:33 +01:00
$builder = new ContainerBuilder ();
2013-12-18 17:52:54 +00:00
$builder -> register ( 'foo' , 'Bar\FooClass' );
2010-05-06 12:25:53 +01:00
$this -> assertTrue ( $builder -> hasDefinition ( 'foo' ), '->register() registers a new service definition' );
2010-08-20 22:09:55 +01:00
$this -> assertInstanceOf ( 'Symfony\Component\DependencyInjection\Definition' , $builder -> getDefinition ( 'foo' ), '->register() returns the newly created Definition instance' );
2010-03-18 07:48:03 +00:00
}
2010-05-06 12:25:53 +01:00
2010-06-27 17:28:29 +01:00
public function testHas ()
2010-03-18 07:48:03 +00:00
{
2010-07-15 14:11:33 +01:00
$builder = new ContainerBuilder ();
2010-06-27 17:28:29 +01:00
$this -> assertFalse ( $builder -> has ( 'foo' ), '->has() returns false if the service does not exist' );
2013-12-18 17:52:54 +00:00
$builder -> register ( 'foo' , 'Bar\FooClass' );
2010-06-27 17:28:29 +01:00
$this -> assertTrue ( $builder -> has ( 'foo' ), '->has() returns true if a service definition exists' );
$builder -> set ( 'bar' , new \stdClass ());
$this -> assertTrue ( $builder -> has ( 'bar' ), '->has() returns true if a service exists' );
2010-03-18 07:48:03 +00:00
}
2010-05-06 12:25:53 +01:00
2010-06-27 17:28:29 +01:00
public function testGet ()
2010-03-18 07:48:03 +00:00
{
2010-07-15 14:11:33 +01:00
$builder = new ContainerBuilder ();
2010-05-07 15:09:11 +01:00
try {
2010-06-27 17:28:29 +01:00
$builder -> get ( 'foo' );
2016-02-07 18:10:24 +00:00
$this -> fail ( '->get() throws a ServiceNotFoundException if the service does not exist' );
} catch ( ServiceNotFoundException $e ) {
$this -> assertEquals ( 'You have requested a non-existent service "foo".' , $e -> getMessage (), '->get() throws a ServiceNotFoundException if the service does not exist' );
2010-05-06 12:25:53 +01:00
}
2010-06-27 17:28:29 +01:00
$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' );
2010-05-06 12:25:53 +01:00
$builder -> register ( 'foo' , 'stdClass' );
2011-01-02 22:08:16 +00:00
$this -> assertInternalType ( 'object' , $builder -> get ( 'foo' ), '->get() returns the service definition associated with the id' );
2010-06-27 17:28:29 +01:00
$builder -> set ( 'bar' , $bar = new \stdClass ());
$this -> assertEquals ( $bar , $builder -> get ( 'bar' ), '->get() returns the service associated with the id' );
2010-05-06 12:25:53 +01:00
$builder -> register ( 'bar' , 'stdClass' );
2010-06-27 17:28:29 +01:00
$this -> assertEquals ( $bar , $builder -> get ( 'bar' ), '->get() returns the service associated with the id even if a definition has been defined' );
2010-05-06 12:25:53 +01:00
$builder -> register ( 'baz' , 'stdClass' ) -> setArguments ( array ( new Reference ( 'baz' )));
2010-05-07 15:09:11 +01:00
try {
2010-06-27 17:28:29 +01:00
@ $builder -> get ( 'baz' );
2011-05-25 08:46:30 +01:00
$this -> fail ( '->get() throws a ServiceCircularReferenceException if the service has a circular reference to itself' );
2016-07-28 12:36:19 +01:00
} catch ( ServiceCircularReferenceException $e ) {
2011-03-14 20:12:42 +00:00
$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' );
2010-05-06 12:25:53 +01:00
}
2011-01-17 22:28:59 +00:00
$builder -> register ( 'foobar' , 'stdClass' ) -> setScope ( 'container' );
2010-06-27 17:28:29 +01:00
$this -> assertTrue ( $builder -> get ( 'bar' ) === $builder -> get ( 'bar' ), '->get() always returns the same instance if the service is shared' );
2010-03-18 07:48:03 +00:00
}
2010-05-06 12:25:53 +01:00
2013-03-06 16:38:10 +00:00
/**
* @ expectedException \Symfony\Component\DependencyInjection\Exception\RuntimeException
* @ expectedExceptionMessage You have requested a synthetic service ( " foo " ) . The DIC does not know how to construct this service .
*/
2013-03-06 16:55:57 +00:00
public function testGetUnsetLoadingServiceWhenCreateServiceThrowsAnException ()
2013-03-06 16:38:10 +00:00
{
$builder = new ContainerBuilder ();
$builder -> register ( 'foo' , 'stdClass' ) -> setSynthetic ( true );
// we expect a RuntimeException here as foo is synthetic
try {
$builder -> get ( 'foo' );
} catch ( RuntimeException $e ) {
}
// we must also have the same RuntimeException here
$builder -> get ( 'foo' );
}
2013-04-17 12:21:11 +01:00
public function testGetReturnsNullOnInactiveScope ()
{
$builder = new ContainerBuilder ();
$builder -> register ( 'foo' , 'stdClass' ) -> setScope ( 'request' );
$this -> assertNull ( $builder -> get ( 'foo' , ContainerInterface :: NULL_ON_INVALID_REFERENCE ));
}
2014-03-27 14:19:35 +00:00
public function testGetReturnsNullOnInactiveScopeWhenServiceIsCreatedByAMethod ()
{
$builder = new ProjectContainer ();
$this -> assertNull ( $builder -> get ( 'foobaz' , ContainerInterface :: NULL_ON_INVALID_REFERENCE ));
}
2010-05-06 12:25:53 +01:00
public function testGetServiceIds ()
2010-03-18 07:48:03 +00:00
{
2010-07-15 14:11:33 +01:00
$builder = new ContainerBuilder ();
2010-05-06 12:25:53 +01:00
$builder -> register ( 'foo' , 'stdClass' );
$builder -> bar = $bar = new \stdClass ();
$builder -> register ( 'bar' , 'stdClass' );
$this -> assertEquals ( array ( 'foo' , 'bar' , 'service_container' ), $builder -> getServiceIds (), '->getServiceIds() returns all defined service ids' );
2010-03-18 07:48:03 +00:00
}
2010-05-06 12:25:53 +01:00
public function testAliases ()
2010-03-18 07:48:03 +00:00
{
2010-07-15 14:11:33 +01:00
$builder = new ContainerBuilder ();
2010-05-06 12:25:53 +01:00
$builder -> register ( 'foo' , 'stdClass' );
$builder -> setAlias ( 'bar' , 'foo' );
$this -> assertTrue ( $builder -> hasAlias ( 'bar' ), '->hasAlias() returns true if the alias exists' );
$this -> assertFalse ( $builder -> hasAlias ( 'foobar' ), '->hasAlias() returns false if the alias does not exist' );
2011-01-07 14:44:29 +00:00
$this -> assertEquals ( 'foo' , ( string ) $builder -> getAlias ( 'bar' ), '->getAlias() returns the aliased service' );
2010-06-27 17:28:29 +01:00
$this -> assertTrue ( $builder -> has ( 'bar' ), '->setAlias() defines a new service' );
$this -> assertTrue ( $builder -> get ( 'bar' ) === $builder -> get ( 'foo' ), '->setAlias() creates a service that is an alias to another one' );
2010-05-06 12:25:53 +01:00
2015-04-25 17:37:49 +01:00
try {
$builder -> setAlias ( 'foobar' , 'foobar' );
$this -> fail ( '->setAlias() throws an InvalidArgumentException if the alias references itself' );
} catch ( \InvalidArgumentException $e ) {
$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' );
}
2010-05-07 15:09:11 +01:00
try {
2010-05-06 12:25:53 +01:00
$builder -> getAlias ( 'foobar' );
$this -> fail ( '->getAlias() throws an InvalidArgumentException if the alias does not exist' );
2010-11-26 21:25:31 +00:00
} catch ( \InvalidArgumentException $e ) {
2010-05-06 12:25:53 +01:00
$this -> assertEquals ( 'The service alias "foobar" does not exist.' , $e -> getMessage (), '->getAlias() throws an InvalidArgumentException if the alias does not exist' );
}
2010-03-18 07:48:03 +00:00
}
2010-05-06 12:25:53 +01:00
public function testGetAliases ()
2010-03-18 07:48:03 +00:00
{
2010-07-15 14:11:33 +01:00
$builder = new ContainerBuilder ();
2010-05-06 12:25:53 +01:00
$builder -> setAlias ( 'bar' , 'foo' );
$builder -> setAlias ( 'foobar' , 'foo' );
2011-01-07 14:44:29 +00:00
$builder -> setAlias ( 'moo' , new Alias ( 'foo' , false ));
$aliases = $builder -> getAliases ();
$this -> assertEquals ( 'foo' , ( string ) $aliases [ 'bar' ]);
$this -> assertTrue ( $aliases [ 'bar' ] -> isPublic ());
$this -> assertEquals ( 'foo' , ( string ) $aliases [ 'foobar' ]);
$this -> assertEquals ( 'foo' , ( string ) $aliases [ 'moo' ]);
$this -> assertFalse ( $aliases [ 'moo' ] -> isPublic ());
2010-05-06 12:25:53 +01:00
$builder -> register ( 'bar' , 'stdClass' );
2011-01-07 14:44:29 +00:00
$this -> assertFalse ( $builder -> hasAlias ( 'bar' ));
2010-06-27 17:28:29 +01:00
$builder -> set ( 'foobar' , 'stdClass' );
2011-01-07 14:44:29 +00:00
$builder -> set ( 'moo' , 'stdClass' );
2012-01-18 13:42:47 +00:00
$this -> assertCount ( 0 , $builder -> getAliases (), '->getAliases() does not return aliased services that have been overridden' );
2010-03-18 07:48:03 +00:00
}
2010-05-06 12:25:53 +01:00
2010-06-27 17:28:29 +01:00
public function testSetAliases ()
{
2010-07-15 14:11:33 +01:00
$builder = new ContainerBuilder ();
2010-06-27 17:28:29 +01:00
$builder -> setAliases ( array ( 'bar' => 'foo' , 'foobar' => 'foo' ));
2011-01-07 14:44:29 +00:00
$aliases = $builder -> getAliases ();
$this -> assertTrue ( isset ( $aliases [ 'bar' ]));
$this -> assertTrue ( isset ( $aliases [ 'foobar' ]));
2010-06-27 17:28:29 +01:00
}
public function testAddAliases ()
{
2010-07-15 14:11:33 +01:00
$builder = new ContainerBuilder ();
2010-06-27 17:28:29 +01:00
$builder -> setAliases ( array ( 'bar' => 'foo' ));
$builder -> addAliases ( array ( 'foobar' => 'foo' ));
2011-01-07 14:44:29 +00:00
$aliases = $builder -> getAliases ();
$this -> assertTrue ( isset ( $aliases [ 'bar' ]));
$this -> assertTrue ( isset ( $aliases [ 'foobar' ]));
2010-06-27 17:28:29 +01:00
}
2016-02-09 19:58:01 +00:00
public function testSetReplacesAlias ()
{
$builder = new ContainerBuilder ();
$builder -> setAlias ( 'alias' , 'aliased' );
$builder -> set ( 'aliased' , new \stdClass ());
$builder -> set ( 'alias' , $foo = new \stdClass ());
$this -> assertSame ( $foo , $builder -> get ( 'alias' ), '->set() replaces an existing alias' );
}
2016-11-22 18:19:49 +00:00
public function testAliasesKeepInvalidBehavior ()
{
$builder = new ContainerBuilder ();
$aliased = new Definition ( 'stdClass' );
$aliased -> addMethodCall ( 'setBar' , array ( new Reference ( 'bar' , ContainerInterface :: IGNORE_ON_INVALID_REFERENCE )));
$builder -> setDefinition ( 'aliased' , $aliased );
$builder -> setAlias ( 'alias' , 'aliased' );
$this -> assertEquals ( new \stdClass (), $builder -> get ( 'alias' ));
}
2011-02-20 12:23:32 +00:00
public function testAddGetCompilerPass ()
{
$builder = new ContainerBuilder ();
2012-12-28 09:40:13 +00:00
$builder -> setResourceTracking ( false );
2011-02-20 12:23:32 +00:00
$builderCompilerPasses = $builder -> getCompiler () -> getPassConfig () -> getPasses ();
2016-12-19 09:02:29 +00:00
$builder -> addCompilerPass ( $this -> getMockBuilder ( 'Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface' ) -> getMock ());
2015-03-06 19:37:36 +00:00
$this -> assertCount ( count ( $builder -> getCompiler () -> getPassConfig () -> getPasses ()) - 1 , $builderCompilerPasses );
2011-02-20 12:23:32 +00:00
}
2010-05-06 12:25:53 +01:00
public function testCreateService ()
2010-03-18 07:48:03 +00:00
{
2010-07-15 14:11:33 +01:00
$builder = new ContainerBuilder ();
2013-12-18 17:52:54 +00:00
$builder -> register ( 'foo1' , 'Bar\FooClass' ) -> setFile ( __DIR__ . '/Fixtures/includes/foo.php' );
$this -> assertInstanceOf ( '\Bar\FooClass' , $builder -> get ( 'foo1' ), '->createService() requires the file defined by the service definition' );
$builder -> register ( 'foo2' , 'Bar\FooClass' ) -> setFile ( __DIR__ . '/Fixtures/includes/%file%.php' );
2010-05-06 12:25:53 +01:00
$builder -> setParameter ( 'file' , 'foo' );
2013-12-18 17:52:54 +00:00
$this -> assertInstanceOf ( '\Bar\FooClass' , $builder -> get ( 'foo2' ), '->createService() replaces parameters in the file provided by the service definition' );
2010-03-18 07:48:03 +00:00
}
2010-05-06 12:25:53 +01:00
2013-03-29 23:21:12 +00:00
public function testCreateProxyWithRealServiceInstantiator ()
{
$builder = new ContainerBuilder ();
2013-12-18 17:52:54 +00:00
$builder -> register ( 'foo1' , 'Bar\FooClass' ) -> setFile ( __DIR__ . '/Fixtures/includes/foo.php' );
2013-03-29 23:21:12 +00:00
$builder -> getDefinition ( 'foo1' ) -> setLazy ( true );
$foo1 = $builder -> get ( 'foo1' );
$this -> assertSame ( $foo1 , $builder -> get ( 'foo1' ), 'The same proxy is retrieved on multiple subsequent calls' );
2013-12-18 17:52:54 +00:00
$this -> assertSame ( 'Bar\FooClass' , get_class ( $foo1 ));
2013-03-29 23:21:12 +00:00
}
2010-05-06 12:25:53 +01:00
public function testCreateServiceClass ()
2010-03-18 07:48:03 +00:00
{
2010-07-15 14:11:33 +01:00
$builder = new ContainerBuilder ();
2010-05-06 12:25:53 +01:00
$builder -> register ( 'foo1' , '%class%' );
$builder -> setParameter ( 'class' , 'stdClass' );
2010-06-27 17:28:29 +01:00
$this -> assertInstanceOf ( '\stdClass' , $builder -> get ( 'foo1' ), '->createService() replaces parameters in the class provided by the service definition' );
2010-03-18 07:48:03 +00:00
}
2010-05-06 12:25:53 +01:00
public function testCreateServiceArguments ()
{
2010-07-15 14:11:33 +01:00
$builder = new ContainerBuilder ();
2010-05-06 12:25:53 +01:00
$builder -> register ( 'bar' , 'stdClass' );
2013-12-18 17:52:54 +00:00
$builder -> register ( 'foo1' , 'Bar\FooClass' ) -> addArgument ( array ( 'foo' => '%value%' , '%value%' => 'foo' , new Reference ( 'bar' ), '%%unescape_it%%' ));
2010-05-06 12:25:53 +01:00
$builder -> setParameter ( 'value' , 'bar' );
2012-06-26 18:33:57 +01:00
$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' );
2010-05-06 12:25:53 +01:00
}
2010-03-18 07:48:03 +00:00
2014-09-27 17:06:30 +01:00
public function testCreateServiceFactory ()
{
$builder = new ContainerBuilder ();
$builder -> register ( 'foo' , 'Bar\FooClass' ) -> setFactory ( 'Bar\FooClass::getInstance' );
$builder -> register ( 'qux' , 'Bar\FooClass' ) -> setFactory ( array ( 'Bar\FooClass' , 'getInstance' ));
$builder -> register ( 'bar' , 'Bar\FooClass' ) -> setFactory ( array ( new Definition ( 'Bar\FooClass' ), 'getInstance' ));
$builder -> register ( 'baz' , 'Bar\FooClass' ) -> setFactory ( array ( new Reference ( 'bar' ), 'getInstance' ));
$this -> assertTrue ( $builder -> get ( 'foo' ) -> called , '->createService() calls the factory method to create the service instance' );
$this -> assertTrue ( $builder -> get ( 'qux' ) -> called , '->createService() calls the factory method to create the service instance' );
$this -> assertTrue ( $builder -> get ( 'bar' ) -> called , '->createService() uses anonymous service as factory' );
$this -> assertTrue ( $builder -> get ( 'baz' ) -> called , '->createService() uses another service as factory' );
}
2017-01-10 14:26:05 +00:00
/**
* @ group legacy
*/
2015-03-14 05:33:51 +00:00
public function testLegacyCreateServiceFactory ()
{
$builder = new ContainerBuilder ();
$builder -> register ( 'bar' , 'Bar\FooClass' );
2015-01-25 07:08:53 +00:00
$builder
2015-03-14 05:27:59 +00:00
-> register ( 'foo1' , 'Bar\FooClass' )
2015-01-25 07:08:53 +00:00
-> setFactoryClass ( '%foo_class%' )
-> setFactoryMethod ( 'getInstance' )
-> addArgument ( array ( 'foo' => '%value%' , '%value%' => 'foo' , new Reference ( 'bar' )))
;
2010-05-06 12:25:53 +01:00
$builder -> setParameter ( 'value' , 'bar' );
2015-03-14 05:27:59 +00:00
$builder -> setParameter ( 'foo_class' , 'Bar\FooClass' );
2010-07-05 08:47:14 +01:00
$this -> assertTrue ( $builder -> get ( 'foo1' ) -> called , '->createService() calls the factory method to create the service instance' );
$this -> assertEquals ( array ( 'foo' => 'bar' , 'bar' => 'foo' , $builder -> get ( 'bar' )), $builder -> get ( 'foo1' ) -> arguments , '->createService() passes the arguments to the factory method' );
2010-05-06 12:25:53 +01:00
}
2010-03-18 07:48:03 +00:00
2017-01-10 14:26:05 +00:00
/**
* @ group legacy
*/
2015-03-14 05:33:51 +00:00
public function testLegacyCreateServiceFactoryService ()
2010-07-04 17:56:48 +01:00
{
2010-07-15 14:11:33 +01:00
$builder = new ContainerBuilder ();
2015-03-14 05:27:59 +00:00
$builder -> register ( 'foo_service' , 'Bar\FooClass' );
2015-01-25 07:08:53 +00:00
$builder
2015-03-14 05:27:59 +00:00
-> register ( 'foo' , 'Bar\FooClass' )
2015-01-25 07:08:53 +00:00
-> setFactoryService ( '%foo_service%' )
-> setFactoryMethod ( 'getInstance' )
;
$builder -> setParameter ( 'foo_service' , 'foo_service' );
$this -> assertTrue ( $builder -> get ( 'foo' ) -> called , '->createService() calls the factory method to create the service instance' );
2014-09-27 17:06:30 +01:00
}
2010-05-06 12:25:53 +01:00
public function testCreateServiceMethodCalls ()
{
2010-07-15 14:11:33 +01:00
$builder = new ContainerBuilder ();
2010-05-06 12:25:53 +01:00
$builder -> register ( 'bar' , 'stdClass' );
2013-12-18 17:52:54 +00:00
$builder -> register ( 'foo1' , 'Bar\FooClass' ) -> addMethodCall ( 'setBar' , array ( array ( '%value%' , new Reference ( 'bar' ))));
2010-05-06 12:25:53 +01:00
$builder -> setParameter ( 'value' , 'bar' );
2010-06-27 17:28:29 +01:00
$this -> assertEquals ( array ( 'bar' , $builder -> get ( 'bar' )), $builder -> get ( 'foo1' ) -> bar , '->createService() replaces the values in the method calls arguments' );
2010-05-06 12:25:53 +01:00
}
2010-03-18 07:48:03 +00:00
2015-10-20 13:28:37 +01:00
public function testCreateServiceMethodCallsWithEscapedParam ()
{
$builder = new ContainerBuilder ();
$builder -> register ( 'bar' , 'stdClass' );
2015-11-23 10:17:36 +00:00
$builder -> register ( 'foo1' , 'Bar\FooClass' ) -> addMethodCall ( 'setBar' , array ( array ( '%%unescape_it%%' )));
2015-10-20 13:28:37 +01:00
$builder -> setParameter ( 'value' , 'bar' );
$this -> assertEquals ( array ( '%unescape_it%' ), $builder -> get ( 'foo1' ) -> bar , '->createService() replaces the values in the method calls arguments' );
}
public function testCreateServiceProperties ()
{
$builder = new ContainerBuilder ();
$builder -> register ( 'bar' , 'stdClass' );
2015-11-23 10:17:36 +00:00
$builder -> register ( 'foo1' , 'Bar\FooClass' ) -> setProperty ( 'bar' , array ( '%value%' , new Reference ( 'bar' ), '%%unescape_it%%' ));
2015-10-20 13:28:37 +01:00
$builder -> setParameter ( 'value' , 'bar' );
$this -> assertEquals ( array ( 'bar' , $builder -> get ( 'bar' ), '%unescape_it%' ), $builder -> get ( 'foo1' ) -> bar , '->createService() replaces the values in the properties' );
}
2010-05-06 12:25:53 +01:00
public function testCreateServiceConfigurator ()
{
2010-07-15 14:11:33 +01:00
$builder = new ContainerBuilder ();
2013-12-18 17:52:54 +00:00
$builder -> register ( 'foo1' , 'Bar\FooClass' ) -> setConfigurator ( 'sc_configure' );
2010-06-27 17:28:29 +01:00
$this -> assertTrue ( $builder -> get ( 'foo1' ) -> configured , '->createService() calls the configurator' );
2010-05-06 12:25:53 +01:00
2013-12-18 17:52:54 +00:00
$builder -> register ( 'foo2' , 'Bar\FooClass' ) -> setConfigurator ( array ( '%class%' , 'configureStatic' ));
2010-05-06 12:25:53 +01:00
$builder -> setParameter ( 'class' , 'BazClass' );
2010-06-27 17:28:29 +01:00
$this -> assertTrue ( $builder -> get ( 'foo2' ) -> configured , '->createService() calls the configurator' );
2010-05-06 12:25:53 +01:00
$builder -> register ( 'baz' , 'BazClass' );
2013-12-18 17:52:54 +00:00
$builder -> register ( 'foo3' , 'Bar\FooClass' ) -> setConfigurator ( array ( new Reference ( 'baz' ), 'configure' ));
2010-06-27 17:28:29 +01:00
$this -> assertTrue ( $builder -> get ( 'foo3' ) -> configured , '->createService() calls the configurator' );
2010-05-06 12:25:53 +01:00
2015-06-02 14:43:57 +01:00
$builder -> register ( 'foo4' , 'Bar\FooClass' ) -> setConfigurator ( array ( $builder -> getDefinition ( 'baz' ), 'configure' ));
$this -> assertTrue ( $builder -> get ( 'foo4' ) -> configured , '->createService() calls the configurator' );
$builder -> register ( 'foo5' , 'Bar\FooClass' ) -> setConfigurator ( 'foo' );
2010-05-07 15:09:11 +01:00
try {
2015-06-02 14:43:57 +01:00
$builder -> get ( 'foo5' );
2010-05-06 12:25:53 +01:00
$this -> fail ( '->createService() throws an InvalidArgumentException if the configure callable is not a valid callable' );
2010-11-26 21:25:31 +00:00
} catch ( \InvalidArgumentException $e ) {
2013-12-18 17:52:54 +00:00
$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' );
2010-05-06 12:25:53 +01:00
}
2010-03-18 07:48:03 +00:00
}
2010-05-06 12:25:53 +01:00
2013-01-21 22:08:41 +00:00
/**
* @ expectedException \RuntimeException
*/
public function testCreateSyntheticService ()
{
$builder = new ContainerBuilder ();
2013-12-18 17:52:54 +00:00
$builder -> register ( 'foo' , 'Bar\FooClass' ) -> setSynthetic ( true );
2013-01-21 22:08:41 +00:00
$builder -> get ( 'foo' );
}
2013-09-02 11:46:47 +01:00
public function testCreateServiceWithExpression ()
{
$builder = new ContainerBuilder ();
$builder -> setParameter ( 'bar' , 'bar' );
$builder -> register ( 'bar' , 'BarClass' );
2013-12-18 17:52:54 +00:00
$builder -> register ( 'foo' , 'Bar\FooClass' ) -> addArgument ( array ( 'foo' => new Expression ( 'service("bar").foo ~ parameter("bar")' )));
2013-09-02 11:46:47 +01:00
$this -> assertEquals ( 'foobar' , $builder -> get ( 'foo' ) -> arguments [ 'foo' ]);
}
2010-05-06 12:25:53 +01:00
public function testResolveServices ()
2010-03-18 07:48:03 +00:00
{
2010-07-15 14:11:33 +01:00
$builder = new ContainerBuilder ();
2013-12-18 17:52:54 +00:00
$builder -> register ( 'foo' , 'Bar\FooClass' );
2010-06-27 17:28:29 +01:00
$this -> assertEquals ( $builder -> get ( 'foo' ), $builder -> resolveServices ( new Reference ( 'foo' )), '->resolveServices() resolves service references to service instances' );
$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' );
2013-09-02 11:46:47 +01:00
$this -> assertEquals ( $builder -> get ( 'foo' ), $builder -> resolveServices ( new Expression ( 'service("foo")' )), '->resolveServices() resolves expressions' );
2010-03-18 07:48:03 +00:00
}
2016-11-17 00:37:44 +00:00
/**
* @ expectedException \Symfony\Component\DependencyInjection\Exception\RuntimeException
2016-11-24 10:37:50 +00:00
* @ expectedExceptionMessage Constructing service " foo " from a parent definition is not supported at build time .
2016-11-17 00:37:44 +00:00
*/
public function testResolveServicesWithDecoratedDefinition ()
{
$builder = new ContainerBuilder ();
$builder -> setDefinition ( 'grandpa' , new Definition ( 'stdClass' ));
$builder -> setDefinition ( 'parent' , new DefinitionDecorator ( 'grandpa' ));
$builder -> setDefinition ( 'foo' , new DefinitionDecorator ( 'parent' ));
$builder -> get ( 'foo' );
}
2016-11-23 17:45:56 +00:00
public function testResolveServicesWithCustomDefinitionClass ()
{
$builder = new ContainerBuilder ();
$builder -> setDefinition ( 'foo' , new CustomDefinition ( 'stdClass' ));
$this -> assertInstanceOf ( 'stdClass' , $builder -> get ( 'foo' ));
}
2010-05-06 12:25:53 +01:00
public function testMerge ()
2010-03-18 07:48:03 +00:00
{
2010-07-15 14:11:33 +01:00
$container = new ContainerBuilder ( new ParameterBag ( array ( 'bar' => 'foo' )));
2012-12-28 09:40:13 +00:00
$container -> setResourceTracking ( false );
2010-07-15 14:11:33 +01:00
$config = new ContainerBuilder ( new ParameterBag ( array ( 'foo' => 'bar' )));
2010-05-06 12:25:53 +01:00
$container -> merge ( $config );
2010-06-27 17:28:29 +01:00
$this -> assertEquals ( array ( 'bar' => 'foo' , 'foo' => 'bar' ), $container -> getParameterBag () -> all (), '->merge() merges current parameters with the loaded ones' );
2010-05-06 12:25:53 +01:00
2010-07-15 14:11:33 +01:00
$container = new ContainerBuilder ( new ParameterBag ( array ( 'bar' => 'foo' )));
2012-12-28 09:40:13 +00:00
$container -> setResourceTracking ( false );
2010-07-15 14:11:33 +01:00
$config = new ContainerBuilder ( new ParameterBag ( array ( 'foo' => '%bar%' )));
2010-05-06 12:25:53 +01:00
$container -> merge ( $config );
2011-01-16 07:12:36 +00:00
$container -> compile ();
2010-06-27 17:28:29 +01:00
$this -> assertEquals ( array ( 'bar' => 'foo' , 'foo' => 'foo' ), $container -> getParameterBag () -> all (), '->merge() evaluates the values of the parameters towards already defined ones' );
2010-05-06 12:25:53 +01:00
2010-07-15 14:11:33 +01:00
$container = new ContainerBuilder ( new ParameterBag ( array ( 'bar' => 'foo' )));
2012-12-28 09:40:13 +00:00
$container -> setResourceTracking ( false );
2010-07-15 14:11:33 +01:00
$config = new ContainerBuilder ( new ParameterBag ( array ( 'foo' => '%bar%' , 'baz' => '%foo%' )));
2010-05-06 12:25:53 +01:00
$container -> merge ( $config );
2011-01-16 07:12:36 +00:00
$container -> compile ();
2010-06-27 17:28:29 +01:00
$this -> assertEquals ( array ( 'bar' => 'foo' , 'foo' => 'foo' , 'baz' => 'foo' ), $container -> getParameterBag () -> all (), '->merge() evaluates the values of the parameters towards already defined ones' );
2010-05-06 12:25:53 +01:00
2010-07-15 14:11:33 +01:00
$container = new ContainerBuilder ();
2012-12-28 09:40:13 +00:00
$container -> setResourceTracking ( false );
2013-12-18 17:52:54 +00:00
$container -> register ( 'foo' , 'Bar\FooClass' );
2010-05-06 12:25:53 +01:00
$container -> register ( 'bar' , 'BarClass' );
2010-07-15 14:11:33 +01:00
$config = new ContainerBuilder ();
2010-05-06 12:25:53 +01:00
$config -> setDefinition ( 'baz' , new Definition ( 'BazClass' ));
$config -> setAlias ( 'alias_for_foo' , 'foo' );
$container -> merge ( $config );
$this -> assertEquals ( array ( 'foo' , 'bar' , 'baz' ), array_keys ( $container -> getDefinitions ()), '->merge() merges definitions already defined ones' );
2011-01-07 14:44:29 +00:00
$aliases = $container -> getAliases ();
$this -> assertTrue ( isset ( $aliases [ 'alias_for_foo' ]));
$this -> assertEquals ( 'foo' , ( string ) $aliases [ 'alias_for_foo' ]);
2010-05-06 12:25:53 +01:00
2010-07-15 14:11:33 +01:00
$container = new ContainerBuilder ();
2012-12-28 09:40:13 +00:00
$container -> setResourceTracking ( false );
2013-12-18 17:52:54 +00:00
$container -> register ( 'foo' , 'Bar\FooClass' );
2010-05-06 12:25:53 +01:00
$config -> setDefinition ( 'foo' , new Definition ( 'BazClass' ));
$container -> merge ( $config );
$this -> assertEquals ( 'BazClass' , $container -> getDefinition ( 'foo' ) -> getClass (), '->merge() overrides already defined services' );
2010-03-18 07:48:03 +00:00
}
2010-05-06 12:25:53 +01:00
2010-10-17 16:26:47 +01:00
/**
2013-11-25 08:44:14 +00:00
* @ expectedException \LogicException
2010-10-17 16:26:47 +01:00
*/
public function testMergeLogicException ()
{
$container = new ContainerBuilder ();
2012-12-28 09:40:13 +00:00
$container -> setResourceTracking ( false );
2011-01-16 07:12:36 +00:00
$container -> compile ();
2010-10-17 16:26:47 +01:00
$container -> merge ( new ContainerBuilder ());
}
2010-08-05 06:34:53 +01:00
public function testfindTaggedServiceIds ()
2010-03-18 07:48:03 +00:00
{
2010-07-15 14:11:33 +01:00
$builder = new ContainerBuilder ();
2010-05-06 12:25:53 +01:00
$builder
2013-12-18 17:52:54 +00:00
-> register ( 'foo' , 'Bar\FooClass' )
2010-08-05 06:34:53 +01:00
-> addTag ( 'foo' , array ( 'foo' => 'foo' ))
-> addTag ( 'bar' , array ( 'bar' => 'bar' ))
-> addTag ( 'foo' , array ( 'foofoo' => 'foofoo' ))
2010-05-06 12:25:53 +01:00
;
2010-08-05 06:34:53 +01:00
$this -> assertEquals ( $builder -> findTaggedServiceIds ( 'foo' ), array (
2010-05-06 12:25:53 +01:00
'foo' => array (
array ( 'foo' => 'foo' ),
array ( 'foofoo' => 'foofoo' ),
2014-09-21 19:53:12 +01:00
),
2010-08-05 06:34:53 +01:00
), '->findTaggedServiceIds() returns an array of service ids and its tag attributes' );
$this -> assertEquals ( array (), $builder -> findTaggedServiceIds ( 'foobar' ), '->findTaggedServiceIds() returns an empty array if there is annotated services' );
2010-03-18 07:48:03 +00:00
}
2010-07-15 14:11:33 +01:00
public function testFindDefinition ()
{
$container = new ContainerBuilder ();
2013-12-18 17:52:54 +00:00
$container -> setDefinition ( 'foo' , $definition = new Definition ( 'Bar\FooClass' ));
2010-07-15 14:11:33 +01:00
$container -> setAlias ( 'bar' , 'foo' );
$container -> setAlias ( 'foobar' , 'bar' );
$this -> assertEquals ( $definition , $container -> findDefinition ( 'foobar' ), '->findDefinition() returns a Definition' );
}
2013-03-29 23:21:12 +00:00
public function testAddObjectResource ()
{
$container = new ContainerBuilder ();
$container -> setResourceTracking ( false );
$container -> addObjectResource ( new \BarClass ());
$this -> assertEmpty ( $container -> getResources (), 'No resources get registered without resource tracking' );
$container -> setResourceTracking ( true );
$container -> addObjectResource ( new \BarClass ());
$resources = $container -> getResources ();
$this -> assertCount ( 1 , $resources , '1 resource was registered' );
/* @var $resource \Symfony\Component\Config\Resource\FileResource */
$resource = end ( $resources );
$this -> assertInstanceOf ( 'Symfony\Component\Config\Resource\FileResource' , $resource );
$this -> assertSame ( realpath ( __DIR__ . '/Fixtures/includes/classes.php' ), realpath ( $resource -> getResource ()));
}
public function testAddClassResource ()
{
$container = new ContainerBuilder ();
$container -> setResourceTracking ( false );
$container -> addClassResource ( new \ReflectionClass ( 'BarClass' ));
$this -> assertEmpty ( $container -> getResources (), 'No resources get registered without resource tracking' );
$container -> setResourceTracking ( true );
$container -> addClassResource ( new \ReflectionClass ( 'BarClass' ));
$resources = $container -> getResources ();
$this -> assertCount ( 1 , $resources , '1 resource was registered' );
/* @var $resource \Symfony\Component\Config\Resource\FileResource */
$resource = end ( $resources );
$this -> assertInstanceOf ( 'Symfony\Component\Config\Resource\FileResource' , $resource );
$this -> assertSame ( realpath ( __DIR__ . '/Fixtures/includes/classes.php' ), realpath ( $resource -> getResource ()));
}
public function testCompilesClassDefinitionsOfLazyServices ()
{
$container = new ContainerBuilder ();
$this -> assertEmpty ( $container -> getResources (), 'No resources get registered without resource tracking' );
$container -> register ( 'foo' , 'BarClass' );
$container -> getDefinition ( 'foo' ) -> setLazy ( true );
$container -> compile ();
2014-10-22 19:27:13 +01:00
$classesPath = realpath ( __DIR__ . '/Fixtures/includes/classes.php' );
2013-03-29 23:21:12 +00:00
$matchingResources = array_filter (
$container -> getResources (),
function ( ResourceInterface $resource ) use ( $classesPath ) {
return $resource instanceof FileResource && $classesPath === realpath ( $resource -> getResource ());
}
);
$this -> assertNotEmpty ( $matchingResources );
}
2010-07-15 14:11:33 +01:00
public function testResources ()
{
$container = new ContainerBuilder ();
$container -> addResource ( $a = new FileResource ( __DIR__ . '/Fixtures/xml/services1.xml' ));
$container -> addResource ( $b = new FileResource ( __DIR__ . '/Fixtures/xml/services2.xml' ));
2011-01-16 07:38:41 +00:00
$resources = array ();
foreach ( $container -> getResources () as $resource ) {
if ( false === strpos ( $resource , '.php' )) {
$resources [] = $resource ;
}
}
$this -> assertEquals ( array ( $a , $b ), $resources , '->getResources() returns an array of resources read for the current configuration' );
2011-09-16 12:43:09 +01:00
$this -> assertSame ( $container , $container -> setResources ( array ()));
$this -> assertEquals ( array (), $container -> getResources ());
2010-07-15 14:11:33 +01:00
}
2010-07-16 08:12:58 +01:00
public function testExtension ()
{
$container = new ContainerBuilder ();
2012-12-28 09:40:13 +00:00
$container -> setResourceTracking ( false );
2010-07-16 08:12:58 +01:00
$container -> registerExtension ( $extension = new \ProjectExtension ());
$this -> assertTrue ( $container -> getExtension ( 'project' ) === $extension , '->registerExtension() registers an extension' );
2010-10-17 16:26:47 +01:00
2017-02-20 14:23:32 +00:00
$this -> { method_exists ( $this , $_ = 'expectException' ) ? $_ : 'setExpectedException' }( 'LogicException' );
2010-10-17 16:26:47 +01:00
$container -> getExtension ( 'no_registered' );
2010-07-16 08:12:58 +01:00
}
2010-10-02 15:47:35 +01:00
2011-03-03 12:53:29 +00:00
public function testRegisteredButNotLoadedExtension ()
{
2016-12-19 09:02:29 +00:00
$extension = $this -> getMockBuilder ( 'Symfony\\Component\\DependencyInjection\\Extension\\ExtensionInterface' ) -> getMock ();
2011-03-03 12:53:29 +00:00
$extension -> expects ( $this -> once ()) -> method ( 'getAlias' ) -> will ( $this -> returnValue ( 'project' ));
$extension -> expects ( $this -> never ()) -> method ( 'load' );
$container = new ContainerBuilder ();
2012-12-28 09:40:13 +00:00
$container -> setResourceTracking ( false );
2011-03-03 12:53:29 +00:00
$container -> registerExtension ( $extension );
$container -> compile ();
}
public function testRegisteredAndLoadedExtension ()
{
2016-12-19 09:02:29 +00:00
$extension = $this -> getMockBuilder ( 'Symfony\\Component\\DependencyInjection\\Extension\\ExtensionInterface' ) -> getMock ();
2011-03-03 12:53:29 +00:00
$extension -> expects ( $this -> exactly ( 2 )) -> method ( 'getAlias' ) -> will ( $this -> returnValue ( 'project' ));
$extension -> expects ( $this -> once ()) -> method ( 'load' ) -> with ( array ( array ( 'foo' => 'bar' )));
$container = new ContainerBuilder ();
2012-12-28 09:40:13 +00:00
$container -> setResourceTracking ( false );
2011-03-03 12:53:29 +00:00
$container -> registerExtension ( $extension );
$container -> loadFromExtension ( 'project' , array ( 'foo' => 'bar' ));
$container -> compile ();
}
2011-05-23 20:28:47 +01:00
public function testPrivateServiceUser ()
{
2014-10-22 19:27:13 +01:00
$fooDefinition = new Definition ( 'BarClass' );
2011-05-23 20:28:47 +01:00
$fooUserDefinition = new Definition ( 'BarUserClass' , array ( new Reference ( 'bar' )));
2014-10-22 19:27:13 +01:00
$container = new ContainerBuilder ();
2012-12-28 09:40:13 +00:00
$container -> setResourceTracking ( false );
2011-05-23 20:28:47 +01:00
$fooDefinition -> setPublic ( false );
$container -> addDefinitions ( array (
2014-10-22 19:27:13 +01:00
'bar' => $fooDefinition ,
'bar_user' => $fooUserDefinition ,
2011-05-23 20:28:47 +01:00
));
$container -> compile ();
$this -> assertInstanceOf ( 'BarClass' , $container -> get ( 'bar_user' ) -> bar );
}
2010-10-02 15:47:35 +01:00
/**
2013-11-25 08:44:14 +00:00
* @ expectedException \BadMethodCallException
2010-10-02 15:47:35 +01:00
*/
public function testThrowsExceptionWhenSetServiceOnAFrozenContainer ()
{
$container = new ContainerBuilder ();
2012-12-28 09:40:13 +00:00
$container -> setResourceTracking ( false );
2012-12-28 08:42:17 +00:00
$container -> setDefinition ( 'a' , new Definition ( 'stdClass' ));
2011-01-16 07:12:36 +00:00
$container -> compile ();
2010-10-02 15:47:35 +01:00
$container -> set ( 'a' , new \stdClass ());
}
2012-12-28 08:42:17 +00:00
public function testThrowsExceptionWhenAddServiceOnAFrozenContainer ()
{
$container = new ContainerBuilder ();
$container -> compile ();
2016-09-06 14:11:47 +01:00
$container -> set ( 'a' , $foo = new \stdClass ());
$this -> assertSame ( $foo , $container -> get ( 'a' ));
2012-12-28 08:42:17 +00:00
}
public function testNoExceptionWhenSetSyntheticServiceOnAFrozenContainer ()
{
$container = new ContainerBuilder ();
$def = new Definition ( 'stdClass' );
$def -> setSynthetic ( true );
$container -> setDefinition ( 'a' , $def );
$container -> compile ();
$container -> set ( 'a' , $a = new \stdClass ());
$this -> assertEquals ( $a , $container -> get ( 'a' ));
}
2015-03-13 17:49:40 +00:00
/**
* @ group legacy
*/
2015-01-06 16:17:37 +00:00
public function testLegacySetOnSynchronizedService ()
2013-02-06 20:42:01 +00:00
{
$container = new ContainerBuilder ();
$container -> register ( 'baz' , 'BazClass' )
-> setSynchronized ( true )
;
$container -> register ( 'bar' , 'BarClass' )
-> addMethodCall ( 'setBaz' , array ( new Reference ( 'baz' )))
;
$container -> set ( 'baz' , $baz = new \BazClass ());
$this -> assertSame ( $baz , $container -> get ( 'bar' ) -> getBaz ());
$container -> set ( 'baz' , $baz = new \BazClass ());
$this -> assertSame ( $baz , $container -> get ( 'bar' ) -> getBaz ());
}
2015-03-13 17:49:40 +00:00
/**
* @ group legacy
*/
2015-01-06 16:17:37 +00:00
public function testLegacySynchronizedServiceWithScopes ()
2013-02-06 20:42:01 +00:00
{
$container = new ContainerBuilder ();
$container -> addScope ( new Scope ( 'foo' ));
$container -> register ( 'baz' , 'BazClass' )
-> setSynthetic ( true )
-> setSynchronized ( true )
-> setScope ( 'foo' )
;
$container -> register ( 'bar' , 'BarClass' )
-> addMethodCall ( 'setBaz' , array ( new Reference ( 'baz' , ContainerInterface :: NULL_ON_INVALID_REFERENCE , false )))
;
$container -> compile ();
$container -> enterScope ( 'foo' );
$container -> set ( 'baz' , $outerBaz = new \BazClass (), 'foo' );
$this -> assertSame ( $outerBaz , $container -> get ( 'bar' ) -> getBaz ());
$container -> enterScope ( 'foo' );
$container -> set ( 'baz' , $innerBaz = new \BazClass (), 'foo' );
$this -> assertSame ( $innerBaz , $container -> get ( 'bar' ) -> getBaz ());
$container -> leaveScope ( 'foo' );
$this -> assertNotSame ( $innerBaz , $container -> get ( 'bar' ) -> getBaz ());
$this -> assertSame ( $outerBaz , $container -> get ( 'bar' ) -> getBaz ());
$container -> leaveScope ( 'foo' );
}
2010-10-02 15:47:35 +01:00
/**
2013-11-25 08:44:14 +00:00
* @ expectedException \BadMethodCallException
2010-10-02 15:47:35 +01:00
*/
public function testThrowsExceptionWhenSetDefinitionOnAFrozenContainer ()
{
$container = new ContainerBuilder ();
2012-12-28 09:40:13 +00:00
$container -> setResourceTracking ( false );
2011-01-16 07:12:36 +00:00
$container -> compile ();
2010-10-02 15:47:35 +01:00
$container -> setDefinition ( 'a' , new Definition ());
}
2012-09-20 22:20:53 +01:00
public function testExtensionConfig ()
{
$container = new ContainerBuilder ();
$configs = $container -> getExtensionConfig ( 'foo' );
$this -> assertEmpty ( $configs );
$first = array ( 'foo' => 'bar' );
$container -> prependExtensionConfig ( 'foo' , $first );
$configs = $container -> getExtensionConfig ( 'foo' );
$this -> assertEquals ( array ( $first ), $configs );
$second = array ( 'ding' => 'dong' );
$container -> prependExtensionConfig ( 'foo' , $second );
$configs = $container -> getExtensionConfig ( 'foo' );
$this -> assertEquals ( array ( $second , $first ), $configs );
}
2013-11-09 11:47:52 +00:00
2016-04-05 14:46:37 +01:00
public function testAbstractAlias ()
{
$container = new ContainerBuilder ();
$abstract = new Definition ( 'AbstractClass' );
$abstract -> setAbstract ( true );
$container -> setDefinition ( 'abstract_service' , $abstract );
$container -> setAlias ( 'abstract_alias' , 'abstract_service' );
$container -> compile ();
$this -> assertSame ( 'abstract_service' , ( string ) $container -> getAlias ( 'abstract_alias' ));
}
2013-11-09 11:47:52 +00:00
public function testLazyLoadedService ()
{
$loader = new ClosureLoader ( $container = new ContainerBuilder ());
$loader -> load ( function ( ContainerBuilder $container ) {
2016-10-30 09:34:06 +00:00
$container -> set ( 'a' , new \BazClass ());
$definition = new Definition ( 'BazClass' );
$definition -> setLazy ( true );
$container -> setDefinition ( 'a' , $definition );
});
2013-11-09 11:47:52 +00:00
$container -> setResourceTracking ( true );
$container -> compile ();
$class = new \BazClass ();
$reflectionClass = new \ReflectionClass ( $class );
$r = new \ReflectionProperty ( $container , 'resources' );
$r -> setAccessible ( true );
$resources = $r -> getValue ( $container );
$classInList = false ;
foreach ( $resources as $resource ) {
if ( $resource -> getResource () === $reflectionClass -> getFileName ()) {
$classInList = true ;
break ;
}
}
2014-03-27 14:19:35 +00:00
$this -> assertTrue ( $classInList );
2013-11-09 11:47:52 +00:00
}
2016-11-19 11:21:18 +00:00
public function testInitializePropertiesBeforeMethodCalls ()
{
$container = new ContainerBuilder ();
$container -> register ( 'foo' , 'stdClass' );
$container -> register ( 'bar' , 'MethodCallClass' )
-> setProperty ( 'simple' , 'bar' )
-> setProperty ( 'complex' , new Reference ( 'foo' ))
-> addMethodCall ( 'callMe' );
$container -> compile ();
$this -> assertTrue ( $container -> get ( 'bar' ) -> callPassed (), '->compile() initializes properties before method calls' );
}
2010-03-18 07:48:03 +00:00
}
2010-10-02 15:47:35 +01:00
2014-09-21 19:53:12 +01:00
class FooClass
{
}
2014-03-27 14:19:35 +00:00
class ProjectContainer extends ContainerBuilder
{
public function getFoobazService ()
{
throw new InactiveScopeException ( 'foo' , 'request' );
}
}