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
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 ;
2011-02-20 12:23:32 +00:00
use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface ;
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 ;
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 ;
2010-03-18 07:48:03 +00:00
2010-07-15 14:11:33 +01:00
class ContainerBuilderTest extends \PHPUnit_Framework_TestCase
2010-03-18 07:48:03 +00:00
{
2010-06-27 17:28:29 +01:00
/**
2010-08-20 22:09:55 +01:00
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: setDefinitions
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: getDefinitions
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: setDefinition
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: getDefinition
2010-06-27 17:28:29 +01: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 (
'foo' => new Definition ( 'FooClass' ),
'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' );
$this -> fail ( '->getDefinition() throws an InvalidArgumentException if the service definition 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 definition "baz" does not exist.' , $e -> getMessage (), '->getDefinition() throws an InvalidArgumentException if the service definition does not exist' );
}
2010-03-18 07:48:03 +00:00
}
2010-05-06 12:25:53 +01:00
2010-06-27 17:28:29 +01:00
/**
2010-08-20 22:09:55 +01:00
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: register
2010-06-27 17:28:29 +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 ();
2010-05-06 12:25:53 +01:00
$builder -> register ( 'foo' , 'FooClass' );
$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
/**
2010-08-20 22:09:55 +01:00
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: has
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' );
2010-05-06 12:25:53 +01:00
$builder -> register ( 'foo' , '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
/**
2010-08-20 22:09:55 +01:00
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: get
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' );
$this -> fail ( '->get() throws an InvalidArgumentException if the service does not exist' );
2010-11-26 21:25:31 +00:00
} catch ( \InvalidArgumentException $e ) {
2010-06-27 17:28:29 +01:00
$this -> assertEquals ( 'The service definition "foo" does not exist.' , $e -> getMessage (), '->get() throws an InvalidArgumentException 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' );
} catch ( \Symfony\Component\DependencyInjection\Exception\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
/**
* @ covers \Symfony\Component\DependencyInjection\ContainerBuilder :: get
* @ 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
/**
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: get
*/
public function testGetReturnsNullOnInactiveScope ()
{
$builder = new ContainerBuilder ();
$builder -> register ( 'foo' , 'stdClass' ) -> setScope ( 'request' );
$this -> assertNull ( $builder -> get ( 'foo' , ContainerInterface :: NULL_ON_INVALID_REFERENCE ));
}
2010-06-27 17:28:29 +01:00
/**
2010-08-20 22:09:55 +01:00
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: getServiceIds
2010-06-27 17:28:29 +01:00
*/
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-06-27 17:28:29 +01:00
/**
2010-08-20 22:09:55 +01:00
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: setAlias
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: hasAlias
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: getAlias
2010-06-27 17:28:29 +01: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
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
2010-06-27 17:28:29 +01:00
/**
2010-08-20 22:09:55 +01:00
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: getAliases
2010-06-27 17:28:29 +01: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
/**
2010-08-20 22:09:55 +01:00
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: setAliases
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
}
/**
2010-08-20 22:09:55 +01:00
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: addAliases
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
}
2011-02-20 12:23:32 +00:00
/**
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: addCompilerPass
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: getCompilerPassConfig
*/
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 ();
$builder -> addCompilerPass ( $this -> getMock ( 'Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface' ));
$this -> assertEquals ( sizeof ( $builderCompilerPasses ) + 1 , sizeof ( $builder -> getCompiler () -> getPassConfig () -> getPasses ()));
}
2010-06-27 17:28:29 +01:00
/**
2010-08-20 22:09:55 +01:00
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: createService
2010-06-27 17:28:29 +01: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 ();
2010-07-04 17:56:48 +01:00
$builder -> register ( 'foo1' , 'FooClass' ) -> setFile ( __DIR__ . '/Fixtures/includes/foo.php' );
2010-06-27 17:28:29 +01:00
$this -> assertInstanceOf ( '\FooClass' , $builder -> get ( 'foo1' ), '->createService() requires the file defined by the service definition' );
2010-07-04 17:56:48 +01:00
$builder -> register ( 'foo2' , 'FooClass' ) -> setFile ( __DIR__ . '/Fixtures/includes/%file%.php' );
2010-05-06 12:25:53 +01:00
$builder -> setParameter ( 'file' , 'foo' );
2010-06-27 17:28:29 +01:00
$this -> assertInstanceOf ( '\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
/**
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: createService
*/
public function testCreateProxyWithRealServiceInstantiator ()
{
$builder = new ContainerBuilder ();
$builder -> register ( 'foo1' , 'FooClass' ) -> setFile ( __DIR__ . '/Fixtures/includes/foo.php' );
$builder -> getDefinition ( 'foo1' ) -> setLazy ( true );
$foo1 = $builder -> get ( 'foo1' );
$this -> assertSame ( $foo1 , $builder -> get ( 'foo1' ), 'The same proxy is retrieved on multiple subsequent calls' );
$this -> assertSame ( 'FooClass' , get_class ( $foo1 ));
}
2010-06-27 17:28:29 +01:00
/**
2010-08-20 22:09:55 +01:00
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: createService
2010-06-27 17:28:29 +01: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-06-27 17:28:29 +01:00
/**
2010-08-20 22:09:55 +01:00
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: createService
2010-06-27 17:28:29 +01: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' );
2012-06-26 18:33:57 +01:00
$builder -> register ( 'foo1' , '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
2010-06-27 17:28:29 +01:00
/**
2010-08-20 22:09:55 +01:00
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: createService
2010-06-27 17:28:29 +01:00
*/
2010-07-05 08:47:14 +01:00
public function testCreateServiceFactoryMethod ()
2010-05-06 12:25:53 +01:00
{
2010-07-15 14:11:33 +01:00
$builder = new ContainerBuilder ();
2010-05-06 12:25:53 +01:00
$builder -> register ( 'bar' , 'stdClass' );
2011-02-02 17:22:27 +00:00
$builder -> register ( 'foo1' , 'FooClass' ) -> setFactoryClass ( 'FooClass' ) -> setFactoryMethod ( 'getInstance' ) -> addArgument ( array ( 'foo' => '%value%' , '%value%' => 'foo' , new Reference ( 'bar' )));
2010-05-06 12:25:53 +01:00
$builder -> setParameter ( 'value' , 'bar' );
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
2010-07-04 17:56:48 +01:00
/**
2010-08-20 22:09:55 +01:00
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: createService
2010-07-04 17:56:48 +01:00
*/
public function testCreateServiceFactoryService ()
{
2010-07-15 14:11:33 +01:00
$builder = new ContainerBuilder ();
2010-07-04 17:56:48 +01:00
$builder -> register ( 'baz_service' ) -> setFactoryService ( 'baz_factory' ) -> setFactoryMethod ( 'getInstance' );
$builder -> register ( 'baz_factory' , 'BazClass' );
2011-01-02 22:08:16 +00:00
$this -> assertInstanceOf ( 'BazClass' , $builder -> get ( 'baz_service' ));
2010-07-04 17:56:48 +01:00
}
2010-06-27 17:28:29 +01:00
/**
2010-08-20 22:09:55 +01:00
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: createService
2010-06-27 17:28:29 +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' );
$builder -> register ( 'foo1' , 'FooClass' ) -> addMethodCall ( 'setBar' , array ( array ( '%value%' , new Reference ( 'bar' ))));
$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
2010-06-27 17:28:29 +01:00
/**
2010-08-20 22:09:55 +01:00
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: createService
2010-06-27 17:28:29 +01:00
*/
2010-05-06 12:25:53 +01:00
public function testCreateServiceConfigurator ()
{
2010-07-15 14:11:33 +01:00
$builder = new ContainerBuilder ();
2010-05-06 12:25:53 +01:00
$builder -> register ( 'foo1' , '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
$builder -> register ( 'foo2' , 'FooClass' ) -> setConfigurator ( array ( '%class%' , 'configureStatic' ));
$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' );
$builder -> register ( 'foo3' , '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
$builder -> register ( 'foo4' , 'FooClass' ) -> setConfigurator ( 'foo' );
2010-05-07 15:09:11 +01:00
try {
2010-06-27 17:28:29 +01:00
$builder -> get ( 'foo4' );
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 ) {
2010-05-06 12:25:53 +01:00
$this -> assertEquals ( 'The configure callable for class "FooClass" is not a callable.' , $e -> getMessage (), '->createService() throws an InvalidArgumentException if the configure callable is not a valid callable' );
}
2010-03-18 07:48:03 +00:00
}
2010-05-06 12:25:53 +01:00
2013-01-21 22:08:41 +00:00
/**
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: createService
* @ expectedException \RuntimeException
*/
public function testCreateSyntheticService ()
{
$builder = new ContainerBuilder ();
$builder -> register ( 'foo' , 'FooClass' ) -> setSynthetic ( true );
$builder -> get ( 'foo' );
}
2010-06-27 17:28:29 +01:00
/**
2010-08-20 22:09:55 +01:00
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: resolveServices
2010-06-27 17:28:29 +01:00
*/
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 ();
2010-05-06 12:25:53 +01:00
$builder -> register ( 'foo' , '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' );
2010-03-18 07:48:03 +00:00
}
2010-06-27 17:28:29 +01:00
/**
2010-08-20 22:09:55 +01:00
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: merge
2010-06-27 17:28:29 +01:00
*/
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 );
2010-07-15 14:11:33 +01:00
////// FIXME
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 );
2010-07-15 14:11:33 +01:00
////// FIXME
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 );
2010-05-06 12:25:53 +01:00
$container -> register ( 'foo' , 'FooClass' );
$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 );
2010-05-06 12:25:53 +01:00
$container -> register ( 'foo' , 'FooClass' );
$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
/**
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: merge
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-06-27 17:28:29 +01:00
/**
2010-08-20 22:09:55 +01:00
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: findTaggedServiceIds
2010-06-27 17:28:29 +01:00
*/
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
-> register ( 'foo' , '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' ),
)
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
/**
2010-08-20 22:09:55 +01:00
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: findDefinition
2010-07-15 14:11:33 +01:00
*/
public function testFindDefinition ()
{
$container = new ContainerBuilder ();
$container -> setDefinition ( 'foo' , $definition = new Definition ( 'FooClass' ));
$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
/**
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: addObjectResource
*/
public function testAddObjectResource ()
{
if ( ! class_exists ( 'Symfony\Component\Config\Resource\FileResource' )) {
$this -> markTestSkipped ( 'The "Config" component is not available' );
}
$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 ()));
}
/**
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: addClassResource
*/
public function testAddClassResource ()
{
if ( ! class_exists ( 'Symfony\Component\Config\Resource\FileResource' )) {
$this -> markTestSkipped ( 'The "Config" component is not available' );
}
$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 ()));
}
/**
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: compile
*/
public function testCompilesClassDefinitionsOfLazyServices ()
{
if ( ! class_exists ( 'Symfony\Component\Config\Resource\FileResource' )) {
$this -> markTestSkipped ( 'The "Config" component is not available' );
}
$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 ();
$classesPath = realpath ( __DIR__ . '/Fixtures/includes/classes.php' );
$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
/**
2010-08-20 22:09:55 +01:00
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: getResources
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: addResource
2010-07-15 14:11:33 +01:00
*/
public function testResources ()
{
2012-03-28 14:43:52 +01:00
if ( ! class_exists ( 'Symfony\Component\Config\Resource\FileResource' )) {
$this -> markTestSkipped ( 'The "Config" component is not available' );
}
2010-07-15 14:11:33 +01:00
$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
/**
2010-08-20 22:09:55 +01:00
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: registerExtension
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: getExtension
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
$this -> setExpectedException ( 'LogicException' );
$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 ()
{
$extension = $this -> getMock ( 'Symfony\\Component\\DependencyInjection\\Extension\\ExtensionInterface' );
$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 ()
{
$extension = $this -> getMock ( 'Symfony\\Component\\DependencyInjection\\Extension\\ExtensionInterface' );
$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 ()
{
$fooDefinition = new Definition ( 'BarClass' );
$fooUserDefinition = new Definition ( 'BarUserClass' , array ( new Reference ( 'bar' )));
$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 (
'bar' => $fooDefinition ,
'bar_user' => $fooUserDefinition
));
$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
/**
2013-11-25 08:44:14 +00:00
* @ expectedException \BadMethodCallException
2012-12-28 08:42:17 +00:00
*/
public function testThrowsExceptionWhenAddServiceOnAFrozenContainer ()
{
if ( ! class_exists ( 'Symfony\Component\Config\Resource\FileResource' )) {
$this -> markTestSkipped ( 'The "Config" component is not available' );
}
$container = new ContainerBuilder ();
$container -> compile ();
$container -> set ( 'a' , new \stdClass ());
}
public function testNoExceptionWhenSetSyntheticServiceOnAFrozenContainer ()
{
if ( ! class_exists ( 'Symfony\Component\Config\Resource\FileResource' )) {
$this -> markTestSkipped ( 'The "Config" component is not available' );
}
$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' ));
}
2013-02-06 20:42:01 +00:00
public function testSetOnSynchronizedService ()
{
$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 ());
}
public function testSynchronizedServiceWithScopes ()
{
$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
/**
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: getExtensionConfig
* @ covers Symfony\Component\DependencyInjection\ContainerBuilder :: prependExtensionConfig
*/
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
public function testLazyLoadedService ()
{
$loader = new ClosureLoader ( $container = new ContainerBuilder ());
$loader -> load ( function ( ContainerBuilder $container ) {
$container -> set ( 'a' , new \BazClass ());
$definition = new Definition ( 'BazClass' );
$definition -> setLazy ( true );
$container -> setDefinition ( 'a' , $definition );
}
);
$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 ;
}
}
$this -> assertEquals ( true , $classInList );
}
2010-03-18 07:48:03 +00:00
}
2010-10-02 15:47:35 +01:00
class FooClass {}