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 ;
2017-02-16 11:05:13 +00:00
use Psr\Container\ContainerInterface as PsrContainerInterface ;
2017-02-02 08:31:13 +00:00
use Symfony\Component\Config\Resource\ComposerResource ;
2013-03-29 23:21:12 +00:00
use Symfony\Component\Config\Resource\ResourceInterface ;
2017-01-30 09:47:16 +00:00
use Symfony\Component\Config\Resource\DirectoryResource ;
2011-01-07 14:44:29 +00:00
use Symfony\Component\DependencyInjection\Alias ;
2016-12-15 07:56:11 +00:00
use Symfony\Component\DependencyInjection\Argument\ClosureProxyArgument ;
2016-12-13 17:37:51 +00:00
use Symfony\Component\DependencyInjection\Argument\IteratorArgument ;
use Symfony\Component\DependencyInjection\Argument\RewindableGenerator ;
2017-02-26 17:31:03 +00:00
use Symfony\Component\DependencyInjection\Argument\ServiceClosureArgument ;
2016-11-28 07:50:06 +00:00
use Symfony\Component\DependencyInjection\ChildDefinition ;
2016-03-05 12:39:12 +00:00
use Symfony\Component\DependencyInjection\Compiler\PassConfig ;
2010-08-20 22:09:55 +01:00
use Symfony\Component\DependencyInjection\ContainerBuilder ;
use Symfony\Component\DependencyInjection\ContainerInterface ;
use Symfony\Component\DependencyInjection\Definition ;
2013-03-06 16:38:10 +00:00
use Symfony\Component\DependencyInjection\Exception\RuntimeException ;
2016-02-07 18:10:24 +00:00
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 ;
2017-02-26 17:31:03 +00:00
use Symfony\Component\DependencyInjection\TypedReference ;
2010-08-20 22:09:55 +01:00
use Symfony\Component\DependencyInjection\ParameterBag\ParameterBag ;
2016-08-12 19:34:27 +01:00
use Symfony\Component\DependencyInjection\ParameterBag\EnvPlaceholderParameterBag ;
2011-02-10 15:15:51 +00:00
use Symfony\Component\Config\Resource\FileResource ;
2017-02-06 23:00:41 +00:00
use Symfony\Component\DependencyInjection\ServiceLocator ;
2016-11-23 17:45:56 +00:00
use Symfony\Component\DependencyInjection\Tests\Fixtures\CustomDefinition ;
2016-10-21 11:29:35 +01:00
use Symfony\Component\DependencyInjection\Tests\Fixtures\CaseSensitiveClass ;
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
{
2017-02-16 11:05:13 +00:00
public function testDefaultRegisteredDefinitions ()
{
$builder = new ContainerBuilder ();
$this -> assertCount ( 1 , $builder -> getDefinitions ());
$this -> assertTrue ( $builder -> hasDefinition ( 'service_container' ));
$definition = $builder -> getDefinition ( 'service_container' );
$this -> assertInstanceOf ( Definition :: class , $definition );
$this -> assertTrue ( $definition -> isSynthetic ());
$this -> assertSame ( ContainerInterface :: class , $definition -> getClass ());
$this -> assertTrue ( $builder -> hasAlias ( PsrContainerInterface :: class ));
$this -> assertTrue ( $builder -> hasAlias ( ContainerInterface :: class ));
}
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
2016-07-01 07:55:04 +01:00
/**
2016-10-20 14:28:37 +01:00
* @ group legacy
* @ expectedDeprecation The " deprecated_foo " service is deprecated . You should stop using it , as it will soon be removed .
2016-07-01 07:55:04 +01:00
*/
2015-08-10 11:33:01 +01:00
public function testCreateDeprecatedService ()
{
2016-10-20 14:28:37 +01:00
$definition = new Definition ( 'stdClass' );
$definition -> setDeprecated ( true );
2015-08-10 11:33:01 +01:00
2016-10-20 14:28:37 +01:00
$builder = new ContainerBuilder ();
$builder -> setDefinition ( 'deprecated_foo' , $definition );
$builder -> get ( 'deprecated_foo' );
2015-08-10 11:33:01 +01: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
2016-11-26 16:34:50 +00:00
public function testAutowire ()
{
$builder = new ContainerBuilder ();
$builder -> autowire ( 'foo' , 'Bar\FooClass' );
$this -> assertTrue ( $builder -> hasDefinition ( 'foo' ), '->autowire() registers a new service definition' );
$this -> assertTrue ( $builder -> getDefinition ( 'foo' ) -> isAutowired (), '->autowire() creates autowired definitions' );
}
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
2016-05-05 07:52:44 +01:00
/**
* @ expectedException \Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException
* @ expectedExceptionMessage You have requested a non - existent service " foo " .
*/
public function testGetThrowsExceptionIfServiceDoesNotExist ()
2010-03-18 07:48:03 +00:00
{
2010-07-15 14:11:33 +01:00
$builder = new ContainerBuilder ();
2016-05-05 07:52:44 +01:00
$builder -> get ( 'foo' );
}
public function testGetReturnsNullIfServiceDoesNotExistAndInvalidReferenceIsUsed ()
{
$builder = new ContainerBuilder ();
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' );
2016-05-05 07:52:44 +01:00
}
2010-06-27 17:28:29 +01:00
2016-05-05 07:52:44 +01:00
/**
* @ expectedException \Symfony\Component\DependencyInjection\Exception\ServiceCircularReferenceException
*/
public function testGetThrowsCircularReferenceExceptionIfServiceHasReferenceToItself ()
{
$builder = new ContainerBuilder ();
$builder -> register ( 'baz' , 'stdClass' ) -> setArguments ( array ( new Reference ( 'baz' )));
$builder -> get ( 'baz' );
}
public function testGetReturnsSameInstanceWhenServiceIsShared ()
{
$builder = new ContainerBuilder ();
$builder -> register ( 'bar' , 'stdClass' );
$this -> assertTrue ( $builder -> get ( 'bar' ) === $builder -> get ( 'bar' ), '->get() always returns the same instance if the service is shared' );
}
public function testGetCreatesServiceBasedOnDefinition ()
{
$builder = new ContainerBuilder ();
2010-05-06 12:25:53 +01:00
$builder -> register ( 'foo' , 'stdClass' );
2016-05-05 07:52:44 +01:00
2011-01-02 22:08:16 +00:00
$this -> assertInternalType ( 'object' , $builder -> get ( 'foo' ), '->get() returns the service definition associated with the id' );
2016-05-05 07:52:44 +01:00
}
public function testGetReturnsRegisteredService ()
{
$builder = new ContainerBuilder ();
2010-06-27 17:28:29 +01:00
$builder -> set ( 'bar' , $bar = new \stdClass ());
2010-05-06 12:25:53 +01:00
2016-05-05 07:52:44 +01:00
$this -> assertSame ( $bar , $builder -> get ( 'bar' ), '->get() returns the service associated with the id' );
}
2010-05-06 12:25:53 +01:00
2016-05-05 07:52:44 +01:00
public function testRegisterDoesNotOverrideExistingService ()
{
$builder = new ContainerBuilder ();
$builder -> set ( 'bar' , $bar = new \stdClass ());
$builder -> register ( 'bar' , 'stdClass' );
$this -> assertSame ( $bar , $builder -> get ( 'bar' ), '->get() returns the service associated with the id even if a definition has been defined' );
2010-03-18 07:48:03 +00:00
}
2010-05-06 12:25:53 +01:00
2015-06-15 03:41:59 +01:00
public function testNonSharedServicesReturnsDifferentInstances ()
{
$builder = new ContainerBuilder ();
$builder -> register ( 'bar' , 'stdClass' ) -> setShared ( false );
$this -> assertNotSame ( $builder -> get ( 'bar' ), $builder -> get ( 'bar' ));
}
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' );
}
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' );
2017-02-16 11:05:13 +00:00
$this -> assertEquals (
array (
'service_container' ,
'foo' ,
'bar' ,
'Psr\Container\ContainerInterface' ,
'Symfony\Component\DependencyInjection\ContainerInterface' ,
),
$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' );
2017-03-21 17:12:21 +00:00
$this -> assertCount ( 2 , $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 );
2016-03-05 12:39:12 +00:00
$defaultPasses = $builder -> getCompiler () -> getPassConfig () -> getPasses ();
2016-12-19 16:09:34 +00:00
$builder -> addCompilerPass ( $pass1 = $this -> getMockBuilder ( 'Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface' ) -> getMock (), PassConfig :: TYPE_BEFORE_OPTIMIZATION , - 5 );
$builder -> addCompilerPass ( $pass2 = $this -> getMockBuilder ( 'Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface' ) -> getMock (), PassConfig :: TYPE_BEFORE_OPTIMIZATION , 10 );
2016-03-05 12:39:12 +00:00
$passes = $builder -> getCompiler () -> getPassConfig () -> getPasses ();
$this -> assertCount ( count ( $passes ) - 2 , $defaultPasses );
// Pass 1 is executed later
$this -> assertTrue ( array_search ( $pass1 , $passes , true ) > array_search ( $pass2 , $passes , true ));
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' );
$builder -> register ( 'foo2' , 'Bar\FooClass' ) -> setFile ( __DIR__ . '/Fixtures/includes/%file%.php' );
2010-05-06 12:25:53 +01:00
$builder -> setParameter ( 'file' , 'foo' );
2016-05-05 07:52:44 +01:00
$this -> assertInstanceOf ( '\Bar\FooClass' , $builder -> get ( 'foo1' ), '->createService() requires the file defined by the service definition' );
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' );
}
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' );
$builder -> register ( 'foo2' , 'Bar\FooClass' ) -> setConfigurator ( array ( '%class%' , 'configureStatic' ));
2010-05-06 12:25:53 +01:00
$builder -> setParameter ( 'class' , 'BazClass' );
$builder -> register ( 'baz' , 'BazClass' );
2013-12-18 17:52:54 +00:00
$builder -> register ( 'foo3' , 'Bar\FooClass' ) -> setConfigurator ( array ( new Reference ( 'baz' ), 'configure' ));
2015-06-02 14:43:57 +01:00
$builder -> register ( 'foo4' , 'Bar\FooClass' ) -> setConfigurator ( array ( $builder -> getDefinition ( 'baz' ), 'configure' ));
2016-05-05 07:52:44 +01:00
$builder -> register ( 'foo5' , 'Bar\FooClass' ) -> setConfigurator ( 'foo' );
$this -> assertTrue ( $builder -> get ( 'foo1' ) -> configured , '->createService() calls the configurator' );
$this -> assertTrue ( $builder -> get ( 'foo2' ) -> configured , '->createService() calls the configurator' );
$this -> assertTrue ( $builder -> get ( 'foo3' ) -> configured , '->createService() calls the configurator' );
2015-06-02 14:43:57 +01:00
$this -> assertTrue ( $builder -> get ( 'foo4' ) -> configured , '->createService() calls the configurator' );
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
2016-12-13 17:37:51 +00:00
public function testCreateServiceWithIteratorArgument ()
{
$builder = new ContainerBuilder ();
$builder -> register ( 'bar' , 'stdClass' );
$builder
-> register ( 'lazy_context' , 'LazyContext' )
-> setArguments ( array ( new IteratorArgument ( array ( 'k1' => new Reference ( 'bar' ), new Reference ( 'invalid' , ContainerInterface :: IGNORE_ON_INVALID_REFERENCE )))))
;
$lazyContext = $builder -> get ( 'lazy_context' );
$this -> assertInstanceOf ( RewindableGenerator :: class , $lazyContext -> lazyValues );
2017-01-29 19:10:36 +00:00
$this -> assertCount ( 1 , $lazyContext -> lazyValues );
2016-12-13 17:37:51 +00:00
$i = 0 ;
foreach ( $lazyContext -> lazyValues as $k => $v ) {
++ $i ;
$this -> assertEquals ( 'k1' , $k );
$this -> assertInstanceOf ( '\stdClass' , $v );
}
// The second argument should have been ignored.
$this -> assertEquals ( 1 , $i );
}
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' ));
2016-11-28 07:50:06 +00:00
$builder -> setDefinition ( 'parent' , new ChildDefinition ( 'grandpa' ));
$builder -> setDefinition ( 'foo' , new ChildDefinition ( 'parent' ));
2016-11-17 00:37:44 +00:00
$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 );
2017-02-16 11:05:13 +00:00
$this -> assertEquals ( array ( 'service_container' , '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' );
2016-08-12 19:34:27 +01:00
$container = new ContainerBuilder ();
$bag = new EnvPlaceholderParameterBag ();
$bag -> get ( 'env(Foo)' );
$config = new ContainerBuilder ( $bag );
2016-11-29 17:32:01 +00:00
$this -> assertSame ( array ( '%env(Bar)%' ), $config -> resolveEnvPlaceholders ( array ( $bag -> get ( 'env(Bar)' ))));
2016-08-12 19:34:27 +01:00
$container -> merge ( $config );
$this -> assertEquals ( array ( 'Foo' => 0 , 'Bar' => 1 ), $container -> getEnvCounters ());
2017-03-31 11:45:36 +01:00
$container = new ContainerBuilder ();
$config = new ContainerBuilder ();
$childDefA = $container -> registerForAutoconfiguration ( 'AInterface' );
$childDefB = $config -> registerForAutoconfiguration ( 'BInterface' );
$container -> merge ( $config );
$this -> assertSame ( array ( 'AInterface' => $childDefA , 'BInterface' => $childDefB ), $container -> getAutomaticInstanceofDefinitions ());
}
/**
* @ expectedException \Symfony\Component\DependencyInjection\Exception\InvalidArgumentException
* @ expectedExceptionMessage AInterface has already been autoconfigured and merge () does not support merging autoconfiguration for the same class / interface .
*/
public function testMergeThrowsExceptionForDuplicateAutomaticInstanceofDefinitions ()
{
$container = new ContainerBuilder ();
$config = new ContainerBuilder ();
$container -> registerForAutoconfiguration ( 'AInterface' );
$config -> registerForAutoconfiguration ( 'AInterface' );
$container -> merge ( $config );
2010-03-18 07:48:03 +00:00
}
2010-05-06 12:25:53 +01:00
2016-11-24 09:31:58 +00:00
public function testResolveEnvValues ()
{
$_ENV [ 'DUMMY_ENV_VAR' ] = 'du%%y' ;
$container = new ContainerBuilder ();
$container -> setParameter ( 'bar' , '%% %env(DUMMY_ENV_VAR)%' );
$this -> assertSame ( '%% du%%%%y' , $container -> resolveEnvPlaceholders ( '%bar%' , true ));
unset ( $_ENV [ 'DUMMY_ENV_VAR' ]);
}
2017-01-29 18:27:06 +00:00
public function testCompileWithResolveEnv ()
{
$_ENV [ 'DUMMY_ENV_VAR' ] = 'du%%y' ;
$container = new ContainerBuilder ();
$container -> setParameter ( 'env(FOO)' , 'Foo' );
$container -> setParameter ( 'bar' , '%% %env(DUMMY_ENV_VAR)%' );
$container -> setParameter ( 'foo' , '%env(FOO)%' );
$container -> compile ( true );
$this -> assertSame ( '% du%%y' , $container -> getParameter ( 'bar' ));
$this -> assertSame ( 'Foo' , $container -> getParameter ( 'foo' ));
unset ( $_ENV [ 'DUMMY_ENV_VAR' ]);
}
/**
* @ expectedException \Symfony\Component\DependencyInjection\Exception\EnvNotFoundException
* @ expectedExceptionMessage Environment variable not found : " FOO " .
*/
public function testCompileWithResolveMissingEnv ()
{
$container = new ContainerBuilder ();
$container -> setParameter ( 'foo' , '%env(FOO)%' );
$container -> compile ( true );
}
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
2014-10-29 09:15:52 +00:00
public function testFindUnusedTags ()
{
$builder = new ContainerBuilder ();
$builder
-> register ( 'foo' , 'Bar\FooClass' )
-> addTag ( 'kernel.event_listener' , array ( 'foo' => 'foo' ))
-> addTag ( 'kenrel.event_listener' , array ( 'bar' => 'bar' ))
;
$builder -> findTaggedServiceIds ( 'kernel.event_listener' );
$this -> assertEquals ( array ( 'kenrel.event_listener' ), $builder -> findUnusedTags (), '->findUnusedTags() returns an array with unused tags' );
}
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 ();
2017-02-02 08:31:13 +00:00
$this -> assertCount ( 2 , $resources , '2 resources were registered' );
2013-03-29 23:21:12 +00:00
/* @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 ()));
}
2017-01-26 15:09:57 +00:00
/**
* @ group legacy
*/
2013-03-29 23:21:12 +00:00
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 ();
2017-02-02 08:31:13 +00:00
$this -> assertCount ( 2 , $resources , '2 resources were registered' );
2013-03-29 23:21:12 +00:00
/* @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 ()));
}
2017-01-26 15:09:57 +00:00
public function testGetReflectionClass ()
{
$container = new ContainerBuilder ();
$container -> setResourceTracking ( false );
$r1 = $container -> getReflectionClass ( 'BarClass' );
$this -> assertEmpty ( $container -> getResources (), 'No resources get registered without resource tracking' );
$container -> setResourceTracking ( true );
$r2 = $container -> getReflectionClass ( 'BarClass' );
$r3 = $container -> getReflectionClass ( 'BarClass' );
$this -> assertNull ( $container -> getReflectionClass ( 'BarMissingClass' ));
$this -> assertEquals ( $r1 , $r2 );
$this -> assertSame ( $r2 , $r3 );
$resources = $container -> getResources ();
2017-02-02 08:31:13 +00:00
$this -> assertCount ( 3 , $resources , '3 resources were registered' );
2017-01-26 15:09:57 +00:00
2017-02-02 08:31:13 +00:00
$this -> assertSame ( 'reflection.BarClass' , ( string ) $resources [ 1 ]);
2017-01-26 15:09:57 +00:00
$this -> assertSame ( 'BarMissingClass' , ( string ) end ( $resources ));
}
2013-03-29 23:21:12 +00:00
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 ();
$matchingResources = array_filter (
$container -> getResources (),
2017-01-26 15:09:57 +00:00
function ( ResourceInterface $resource ) {
return 'reflection.BarClass' === ( string ) $resource ;
2013-03-29 23:21:12 +00:00
}
);
$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
2017-01-30 09:47:16 +00:00
public function testFileExists ()
{
$container = new ContainerBuilder ();
2017-02-02 08:31:13 +00:00
$A = new ComposerResource ();
2017-01-30 09:47:16 +00:00
$a = new FileResource ( __DIR__ . '/Fixtures/xml/services1.xml' );
$b = new FileResource ( __DIR__ . '/Fixtures/xml/services2.xml' );
$c = new DirectoryResource ( $dir = dirname ( $b ));
$this -> assertTrue ( $container -> fileExists (( string ) $a ) && $container -> fileExists (( string ) $b ) && $container -> fileExists ( $dir ));
$resources = array ();
foreach ( $container -> getResources () as $resource ) {
if ( false === strpos ( $resource , '.php' )) {
$resources [] = $resource ;
}
}
2017-02-02 08:31:13 +00:00
$this -> assertEquals ( array ( $A , $a , $b , $c ), $resources , '->getResources() returns an array of resources read for the current configuration' );
2017-01-30 09:47:16 +00: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 16:09:34 +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 16:09:34 +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
*/
2016-08-19 13:18:08 +01:00
public function testThrowsExceptionWhenSetServiceOnACompiledContainer ()
2010-10-02 15:47:35 +01:00
{
$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 ());
}
2016-08-19 13:18:08 +01:00
public function testThrowsExceptionWhenAddServiceOnACompiledContainer ()
2012-12-28 08:42:17 +00:00
{
$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
}
2016-08-19 13:18:08 +01:00
public function testNoExceptionWhenSetSyntheticServiceOnACompiledContainer ()
2012-12-28 08:42:17 +00:00
{
$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' ));
}
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
*/
2016-08-19 13:18:08 +01:00
public function testThrowsExceptionWhenSetDefinitionOnACompiledContainer ()
2010-10-02 15:47:35 +01:00
{
$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 ();
$r = new \ReflectionProperty ( $container , 'resources' );
$r -> setAccessible ( true );
$resources = $r -> getValue ( $container );
$classInList = false ;
foreach ( $resources as $resource ) {
2017-01-26 15:09:57 +00:00
if ( 'reflection.BazClass' === ( string ) $resource ) {
2013-11-09 11:47:52 +00:00
$classInList = true ;
break ;
}
}
2014-03-27 14:19:35 +00:00
$this -> assertTrue ( $classInList );
2013-11-09 11:47:52 +00:00
}
2015-08-24 02:36:41 +01: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' );
}
2016-11-25 12:26:42 +00:00
2015-08-24 02:36:41 +01:00
public function testAutowiring ()
{
$container = new ContainerBuilder ();
2017-04-04 18:35:51 +01:00
$container -> register ( A :: class );
2015-08-24 02:36:41 +01:00
$bDefinition = $container -> register ( 'b' , __NAMESPACE__ . '\B' );
$bDefinition -> setAutowired ( true );
$container -> compile ();
2017-04-04 18:35:51 +01:00
$this -> assertEquals ( A :: class , ( string ) $container -> getDefinition ( 'b' ) -> getArgument ( 0 ));
2015-08-24 02:36:41 +01:00
}
2016-12-15 07:56:11 +00:00
public function testClosureProxy ()
{
$container = new ContainerBuilder ();
$container -> register ( 'foo' , 'stdClass' )
-> setProperty ( 'foo' , new ClosureProxyArgument ( 'bar' , 'c' ))
;
$container -> register ( 'bar' , A :: class );
$foo = $container -> get ( 'foo' );
$this -> assertInstanceOf ( 'Closure' , $foo -> foo );
$this -> assertSame ( 123 , call_user_func ( $foo -> foo ));
}
public function testClosureProxyContainer ()
{
$container = new ContainerBuilder ();
$container -> register ( 'foo' , 'stdClass' )
-> setProperty ( 'foo' , new ClosureProxyArgument ( 'service_container' , 'get' ))
;
$foo = $container -> get ( 'foo' );
$this -> assertInstanceOf ( 'Closure' , $foo -> foo );
$this -> assertSame ( $foo , call_user_func ( $foo -> foo , 'foo' ));
}
public function testClosureProxyOnInvalidNull ()
{
$container = new ContainerBuilder ();
$container -> register ( 'foo' , 'stdClass' )
-> setProperty ( 'foo' , new ClosureProxyArgument ( 'bar' , 'c' , ContainerInterface :: NULL_ON_INVALID_REFERENCE ))
;
$foo = $container -> get ( 'foo' );
$this -> assertNull ( $foo -> foo );
}
/**
* @ expectedException \Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException
* @ expectedExceptionMessage You have requested a non - existent service " bar " .
*/
public function testClosureProxyOnInvalidException ()
{
$container = new ContainerBuilder ();
$container -> register ( 'foo' , 'stdClass' )
-> setProperty ( 'foo' , new ClosureProxyArgument ( 'bar' , 'c' ))
;
$container -> get ( 'foo' );
}
2016-10-21 11:29:35 +01:00
public function testClassFromId ()
{
$container = new ContainerBuilder ();
2017-01-29 15:34:49 +00:00
$unknown = $container -> register ( 'Acme\UnknownClass' );
2016-10-21 11:29:35 +01:00
$autoloadClass = $container -> register ( CaseSensitiveClass :: class );
$container -> compile ();
2017-01-29 15:34:49 +00:00
$this -> assertSame ( 'Acme\UnknownClass' , $unknown -> getClass ());
2016-10-21 11:29:35 +01:00
$this -> assertEquals ( CaseSensitiveClass :: class , $autoloadClass -> getClass ());
}
2017-01-29 15:34:49 +00:00
/**
* @ expectedException \Symfony\Component\DependencyInjection\Exception\RuntimeException
2017-03-24 22:57:27 +00:00
* @ expectedExceptionMessage The definition for " DateTime " has no class attribute , and appears to reference a class or interface in the global namespace .
2017-01-29 15:34:49 +00:00
*/
public function testNoClassFromGlobalNamespaceClassId ()
{
$container = new ContainerBuilder ();
$definition = $container -> register ( \DateTime :: class );
$container -> compile ();
}
2016-10-21 11:29:35 +01:00
/**
* @ expectedException \Symfony\Component\DependencyInjection\Exception\RuntimeException
* @ expectedExceptionMessage The definition for " 123_abc " has no class .
*/
public function testNoClassFromNonClassId ()
{
$container = new ContainerBuilder ();
$definition = $container -> register ( '123_abc' );
$container -> compile ();
}
/**
* @ expectedException \Symfony\Component\DependencyInjection\Exception\RuntimeException
* @ expectedExceptionMessage The definition for " \ foo " has no class .
*/
public function testNoClassFromNsSeparatorId ()
{
$container = new ContainerBuilder ();
$definition = $container -> register ( '\\foo' );
$container -> compile ();
}
2017-02-26 17:31:03 +00:00
public function testServiceLocator ()
{
$container = new ContainerBuilder ();
$container -> register ( 'foo_service' , ServiceLocator :: class )
-> addArgument ( array (
'bar' => new ServiceClosureArgument ( new Reference ( 'bar_service' )),
'baz' => new ServiceClosureArgument ( new TypedReference ( 'baz_service' , 'stdClass' )),
))
;
$container -> register ( 'bar_service' , 'stdClass' ) -> setArguments ( array ( new Reference ( 'baz_service' )));
$container -> register ( 'baz_service' , 'stdClass' ) -> setPublic ( false );
$container -> compile ();
$this -> assertInstanceOf ( ServiceLocator :: class , $foo = $container -> get ( 'foo_service' ));
$this -> assertSame ( $container -> get ( 'bar_service' ), $foo -> get ( 'bar' ));
}
2017-03-31 11:45:36 +01:00
public function testRegisterForAutoconfiguration ()
{
$container = new ContainerBuilder ();
$childDefA = $container -> registerForAutoconfiguration ( 'AInterface' );
$childDefB = $container -> registerForAutoconfiguration ( 'BInterface' );
$this -> assertSame ( array ( 'AInterface' => $childDefA , 'BInterface' => $childDefB ), $container -> getAutomaticInstanceofDefinitions ());
// when called multiple times, the same instance is returned
$this -> assertSame ( $childDefA , $container -> registerForAutoconfiguration ( 'AInterface' ));
}
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
2015-08-24 02:36:41 +01:00
class A
{
2016-12-15 07:56:11 +00:00
public function c ()
{
return 123 ;
}
2015-08-24 02:36:41 +01:00
}
class B
{
public function __construct ( A $a )
{
}
}