496 lines
28 KiB
PHP
496 lines
28 KiB
PHP
<?php
|
|
|
|
/*
|
|
* This file is part of the Symfony package.
|
|
*
|
|
* (c) Fabien Potencier <fabien@symfony.com>
|
|
*
|
|
* For the full copyright and license information, please view the LICENSE
|
|
* file that was distributed with this source code.
|
|
*/
|
|
|
|
namespace Symfony\Component\DependencyInjection\Tests\Loader;
|
|
|
|
use Symfony\Component\DependencyInjection\ContainerInterface;
|
|
use Symfony\Component\DependencyInjection\ContainerBuilder;
|
|
use Symfony\Component\DependencyInjection\Reference;
|
|
use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;
|
|
use Symfony\Component\DependencyInjection\Loader\YamlFileLoader;
|
|
use Symfony\Component\DependencyInjection\Loader\IniFileLoader;
|
|
use Symfony\Component\Config\Loader\LoaderResolver;
|
|
use Symfony\Component\Config\FileLocator;
|
|
use Symfony\Component\ExpressionLanguage\Expression;
|
|
|
|
class XmlFileLoaderTest extends \PHPUnit_Framework_TestCase
|
|
{
|
|
protected static $fixturesPath;
|
|
|
|
public static function setUpBeforeClass()
|
|
{
|
|
self::$fixturesPath = realpath(__DIR__.'/../Fixtures/');
|
|
require_once self::$fixturesPath.'/includes/foo.php';
|
|
require_once self::$fixturesPath.'/includes/ProjectExtension.php';
|
|
require_once self::$fixturesPath.'/includes/ProjectWithXsdExtension.php';
|
|
}
|
|
|
|
public function testLoad()
|
|
{
|
|
$loader = new XmlFileLoader(new ContainerBuilder(), new FileLocator(self::$fixturesPath.'/ini'));
|
|
|
|
try {
|
|
$loader->load('foo.xml');
|
|
$this->fail('->load() throws an InvalidArgumentException if the loaded file does not exist');
|
|
} catch (\Exception $e) {
|
|
$this->assertInstanceOf('InvalidArgumentException', $e, '->load() throws an InvalidArgumentException if the loaded file does not exist');
|
|
$this->assertStringStartsWith('The file "foo.xml" does not exist (in:', $e->getMessage(), '->load() throws an InvalidArgumentException if the loaded file does not exist');
|
|
}
|
|
}
|
|
|
|
public function testParseFile()
|
|
{
|
|
$loader = new XmlFileLoader(new ContainerBuilder(), new FileLocator(self::$fixturesPath.'/ini'));
|
|
$r = new \ReflectionObject($loader);
|
|
$m = $r->getMethod('parseFileToDOM');
|
|
$m->setAccessible(true);
|
|
|
|
try {
|
|
$m->invoke($loader, self::$fixturesPath.'/ini/parameters.ini');
|
|
$this->fail('->parseFileToDOM() throws an InvalidArgumentException if the loaded file is not a valid XML file');
|
|
} catch (\Exception $e) {
|
|
$this->assertInstanceOf('Symfony\\Component\\DependencyInjection\\Exception\\InvalidArgumentException', $e, '->parseFileToDOM() throws an InvalidArgumentException if the loaded file is not a valid XML file');
|
|
$this->assertRegExp(sprintf('#^Unable to parse file ".+%s".$#', 'parameters.ini'), $e->getMessage(), '->parseFileToDOM() throws an InvalidArgumentException if the loaded file is not a valid XML file');
|
|
|
|
$e = $e->getPrevious();
|
|
$this->assertInstanceOf('InvalidArgumentException', $e, '->parseFileToDOM() throws an InvalidArgumentException if the loaded file is not a valid XML file');
|
|
$this->assertStringStartsWith('[ERROR 4] Start tag expected, \'<\' not found (in', $e->getMessage(), '->parseFileToDOM() throws an InvalidArgumentException if the loaded file is not a valid XML file');
|
|
}
|
|
|
|
$loader = new XmlFileLoader(new ContainerBuilder(), new FileLocator(self::$fixturesPath.'/xml'));
|
|
|
|
try {
|
|
$m->invoke($loader, self::$fixturesPath.'/xml/nonvalid.xml');
|
|
$this->fail('->parseFileToDOM() throws an InvalidArgumentException if the loaded file does not validate the XSD');
|
|
} catch (\Exception $e) {
|
|
$this->assertInstanceOf('Symfony\\Component\\DependencyInjection\\Exception\\InvalidArgumentException', $e, '->parseFileToDOM() throws an InvalidArgumentException if the loaded file does not validate the XSD');
|
|
$this->assertRegExp(sprintf('#^Unable to parse file ".+%s".$#', 'nonvalid.xml'), $e->getMessage(), '->parseFileToDOM() throws an InvalidArgumentException if the loaded file is not a valid XML file');
|
|
|
|
$e = $e->getPrevious();
|
|
$this->assertInstanceOf('InvalidArgumentException', $e, '->parseFileToDOM() throws an InvalidArgumentException if the loaded file does not validate the XSD');
|
|
$this->assertStringStartsWith('[ERROR 1845] Element \'nonvalid\': No matching global declaration available for the validation root. (in', $e->getMessage(), '->parseFileToDOM() throws an InvalidArgumentException if the loaded file does not validate the XSD');
|
|
}
|
|
|
|
$xml = $m->invoke($loader, self::$fixturesPath.'/xml/services1.xml');
|
|
$this->assertInstanceOf('DOMDocument', $xml, '->parseFileToDOM() returns an SimpleXMLElement object');
|
|
}
|
|
|
|
public function testLoadParameters()
|
|
{
|
|
$container = new ContainerBuilder();
|
|
$loader = new XmlFileLoader($container, new FileLocator(self::$fixturesPath.'/xml'));
|
|
$loader->load('services2.xml');
|
|
|
|
$actual = $container->getParameterBag()->all();
|
|
$expected = array(
|
|
'a string',
|
|
'foo' => 'bar',
|
|
'values' => array(
|
|
0,
|
|
'integer' => 4,
|
|
100 => null,
|
|
'true',
|
|
true,
|
|
false,
|
|
'on',
|
|
'off',
|
|
'float' => 1.3,
|
|
1000.3,
|
|
'a string',
|
|
array('foo', 'bar'),
|
|
),
|
|
'mixedcase' => array('MixedCaseKey' => 'value'),
|
|
'constant' => PHP_EOL,
|
|
);
|
|
|
|
$this->assertEquals($expected, $actual, '->load() converts XML values to PHP ones');
|
|
}
|
|
|
|
public function testLoadImports()
|
|
{
|
|
$container = new ContainerBuilder();
|
|
$resolver = new LoaderResolver(array(
|
|
new IniFileLoader($container, new FileLocator(self::$fixturesPath.'/xml')),
|
|
new YamlFileLoader($container, new FileLocator(self::$fixturesPath.'/xml')),
|
|
$loader = new XmlFileLoader($container, new FileLocator(self::$fixturesPath.'/xml')),
|
|
));
|
|
$loader->setResolver($resolver);
|
|
$loader->load('services4.xml');
|
|
|
|
$actual = $container->getParameterBag()->all();
|
|
$expected = array(
|
|
'a string',
|
|
'foo' => 'bar',
|
|
'values' => array(
|
|
0,
|
|
'integer' => 4,
|
|
100 => null,
|
|
'true',
|
|
true,
|
|
false,
|
|
'on',
|
|
'off',
|
|
'float' => 1.3,
|
|
1000.3,
|
|
'a string',
|
|
array('foo', 'bar'),
|
|
),
|
|
'mixedcase' => array('MixedCaseKey' => 'value'),
|
|
'constant' => PHP_EOL,
|
|
'bar' => '%foo%',
|
|
'imported_from_ini' => true,
|
|
'imported_from_yaml' => true,
|
|
);
|
|
|
|
$this->assertEquals(array_keys($expected), array_keys($actual), '->load() imports and merges imported files');
|
|
|
|
// Bad import throws no exception due to ignore_errors value.
|
|
$loader->load('services4_bad_import.xml');
|
|
}
|
|
|
|
public function testLoadAnonymousServices()
|
|
{
|
|
$container = new ContainerBuilder();
|
|
$loader = new XmlFileLoader($container, new FileLocator(self::$fixturesPath.'/xml'));
|
|
$loader->load('services5.xml');
|
|
$services = $container->getDefinitions();
|
|
$this->assertCount(4, $services, '->load() attributes unique ids to anonymous services');
|
|
|
|
// anonymous service as an argument
|
|
$args = $services['foo']->getArguments();
|
|
$this->assertCount(1, $args, '->load() references anonymous services as "normal" ones');
|
|
$this->assertInstanceOf('Symfony\\Component\\DependencyInjection\\Reference', $args[0], '->load() converts anonymous services to references to "normal" services');
|
|
$this->assertTrue(isset($services[(string) $args[0]]), '->load() makes a reference to the created ones');
|
|
$inner = $services[(string) $args[0]];
|
|
$this->assertEquals('BarClass', $inner->getClass(), '->load() uses the same configuration as for the anonymous ones');
|
|
|
|
// inner anonymous services
|
|
$args = $inner->getArguments();
|
|
$this->assertCount(1, $args, '->load() references anonymous services as "normal" ones');
|
|
$this->assertInstanceOf('Symfony\\Component\\DependencyInjection\\Reference', $args[0], '->load() converts anonymous services to references to "normal" services');
|
|
$this->assertTrue(isset($services[(string) $args[0]]), '->load() makes a reference to the created ones');
|
|
$inner = $services[(string) $args[0]];
|
|
$this->assertEquals('BazClass', $inner->getClass(), '->load() uses the same configuration as for the anonymous ones');
|
|
$this->assertFalse($inner->isPublic());
|
|
|
|
// anonymous service as a property
|
|
$properties = $services['foo']->getProperties();
|
|
$property = $properties['p'];
|
|
$this->assertInstanceOf('Symfony\\Component\\DependencyInjection\\Reference', $property, '->load() converts anonymous services to references to "normal" services');
|
|
$this->assertTrue(isset($services[(string) $property]), '->load() makes a reference to the created ones');
|
|
$inner = $services[(string) $property];
|
|
$this->assertEquals('BazClass', $inner->getClass(), '->load() uses the same configuration as for the anonymous ones');
|
|
}
|
|
|
|
/**
|
|
* @group legacy
|
|
*/
|
|
public function testLegacyLoadServices()
|
|
{
|
|
$container = new ContainerBuilder();
|
|
$loader = new XmlFileLoader($container, new FileLocator(self::$fixturesPath.'/xml'));
|
|
$loader->load('legacy-services6.xml');
|
|
$services = $container->getDefinitions();
|
|
$this->assertEquals('FooClass', $services['constructor']->getClass());
|
|
$this->assertEquals('getInstance', $services['constructor']->getFactoryMethod());
|
|
$this->assertNull($services['factory_service']->getClass());
|
|
$this->assertEquals('baz_factory', $services['factory_service']->getFactoryService());
|
|
$this->assertEquals('getInstance', $services['factory_service']->getFactoryMethod());
|
|
$this->assertTrue($services['request']->isSynthetic(), '->load() parses the synthetic flag');
|
|
$this->assertTrue($services['request']->isSynchronized(), '->load() parses the synchronized flag');
|
|
$this->assertTrue($services['request']->isLazy(), '->load() parses the lazy flag');
|
|
$this->assertNull($services['request']->getDecoratedService());
|
|
}
|
|
|
|
public function testLoadServices()
|
|
{
|
|
$container = new ContainerBuilder();
|
|
$loader = new XmlFileLoader($container, new FileLocator(self::$fixturesPath.'/xml'));
|
|
$loader->load('services6.xml');
|
|
$services = $container->getDefinitions();
|
|
$this->assertTrue(isset($services['foo']), '->load() parses <service> elements');
|
|
$this->assertInstanceOf('Symfony\\Component\\DependencyInjection\\Definition', $services['foo'], '->load() converts <service> element to Definition instances');
|
|
$this->assertEquals('FooClass', $services['foo']->getClass(), '->load() parses the class attribute');
|
|
$this->assertEquals('container', $services['scope.container']->getScope());
|
|
$this->assertEquals('custom', $services['scope.custom']->getScope());
|
|
$this->assertEquals('prototype', $services['scope.prototype']->getScope());
|
|
$this->assertEquals('%path%/foo.php', $services['file']->getFile(), '->load() parses the file tag');
|
|
$this->assertEquals(array('foo', new Reference('foo'), array(true, false)), $services['arguments']->getArguments(), '->load() parses the argument tags');
|
|
$this->assertEquals('sc_configure', $services['configurator1']->getConfigurator(), '->load() parses the configurator tag');
|
|
$this->assertEquals(array(new Reference('baz', ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE, false), 'configure'), $services['configurator2']->getConfigurator(), '->load() parses the configurator tag');
|
|
$this->assertEquals(array('BazClass', 'configureStatic'), $services['configurator3']->getConfigurator(), '->load() parses the configurator tag');
|
|
$this->assertEquals(array(array('setBar', array()), array('setBar', array(new Expression('service("foo").foo() ~ (container.hasparameter("foo") ? parameter("foo") : "default")')))), $services['method_call1']->getMethodCalls(), '->load() parses the method_call tag');
|
|
$this->assertEquals(array(array('setBar', array('foo', new Reference('foo'), array(true, false)))), $services['method_call2']->getMethodCalls(), '->load() parses the method_call tag');
|
|
$this->assertEquals('factory', $services['new_factory1']->getFactory(), '->load() parses the factory tag');
|
|
$this->assertEquals(array(new Reference('baz', ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE, false), 'getClass'), $services['new_factory2']->getFactory(), '->load() parses the factory tag');
|
|
$this->assertEquals(array('BazClass', 'getInstance'), $services['new_factory3']->getFactory(), '->load() parses the factory tag');
|
|
|
|
$aliases = $container->getAliases();
|
|
$this->assertTrue(isset($aliases['alias_for_foo']), '->load() parses <service> elements');
|
|
$this->assertEquals('foo', (string) $aliases['alias_for_foo'], '->load() parses aliases');
|
|
$this->assertTrue($aliases['alias_for_foo']->isPublic());
|
|
$this->assertTrue(isset($aliases['another_alias_for_foo']));
|
|
$this->assertEquals('foo', (string) $aliases['another_alias_for_foo']);
|
|
$this->assertFalse($aliases['another_alias_for_foo']->isPublic());
|
|
|
|
$this->assertEquals(array('decorated', null), $services['decorator_service']->getDecoratedService());
|
|
$this->assertEquals(array('decorated', 'decorated.pif-pouf'), $services['decorator_service_with_name']->getDecoratedService());
|
|
}
|
|
|
|
public function testParsesTags()
|
|
{
|
|
$container = new ContainerBuilder();
|
|
$loader = new XmlFileLoader($container, new FileLocator(self::$fixturesPath.'/xml'));
|
|
$loader->load('services10.xml');
|
|
|
|
$services = $container->findTaggedServiceIds('foo_tag');
|
|
$this->assertCount(1, $services);
|
|
|
|
foreach ($services as $id => $tagAttributes) {
|
|
foreach ($tagAttributes as $attributes) {
|
|
$this->assertArrayHasKey('other_option', $attributes);
|
|
$this->assertEquals('lorem', $attributes['other_option']);
|
|
$this->assertArrayHasKey('other-option', $attributes, 'unnormalized tag attributes should not be removed');
|
|
|
|
$this->assertEquals('ciz', $attributes['some_option'], 'no overriding should be done when normalizing');
|
|
$this->assertEquals('cat', $attributes['some-option']);
|
|
|
|
$this->assertArrayNotHasKey('an_other_option', $attributes, 'normalization should not be done when an underscore is already found');
|
|
}
|
|
}
|
|
}
|
|
|
|
public function testConvertDomElementToArray()
|
|
{
|
|
$doc = new \DOMDocument('1.0');
|
|
$doc->loadXML('<foo>bar</foo>');
|
|
$this->assertEquals('bar', XmlFileLoader::convertDomElementToArray($doc->documentElement), '::convertDomElementToArray() converts a \DomElement to an array');
|
|
|
|
$doc = new \DOMDocument('1.0');
|
|
$doc->loadXML('<foo foo="bar" />');
|
|
$this->assertEquals(array('foo' => 'bar'), XmlFileLoader::convertDomElementToArray($doc->documentElement), '::convertDomElementToArray() converts a \DomElement to an array');
|
|
|
|
$doc = new \DOMDocument('1.0');
|
|
$doc->loadXML('<foo><foo>bar</foo></foo>');
|
|
$this->assertEquals(array('foo' => 'bar'), XmlFileLoader::convertDomElementToArray($doc->documentElement), '::convertDomElementToArray() converts a \DomElement to an array');
|
|
|
|
$doc = new \DOMDocument('1.0');
|
|
$doc->loadXML('<foo><foo>bar<foo>bar</foo></foo></foo>');
|
|
$this->assertEquals(array('foo' => array('value' => 'bar', 'foo' => 'bar')), XmlFileLoader::convertDomElementToArray($doc->documentElement), '::convertDomElementToArray() converts a \DomElement to an array');
|
|
|
|
$doc = new \DOMDocument('1.0');
|
|
$doc->loadXML('<foo><foo></foo></foo>');
|
|
$this->assertEquals(array('foo' => null), XmlFileLoader::convertDomElementToArray($doc->documentElement), '::convertDomElementToArray() converts a \DomElement to an array');
|
|
|
|
$doc = new \DOMDocument('1.0');
|
|
$doc->loadXML('<foo><foo><!-- foo --></foo></foo>');
|
|
$this->assertEquals(array('foo' => null), XmlFileLoader::convertDomElementToArray($doc->documentElement), '::convertDomElementToArray() converts a \DomElement to an array');
|
|
|
|
$doc = new \DOMDocument('1.0');
|
|
$doc->loadXML('<foo><foo foo="bar"/><foo foo="bar"/></foo>');
|
|
$this->assertEquals(array('foo' => array(array('foo' => 'bar'), array('foo' => 'bar'))), XmlFileLoader::convertDomElementToArray($doc->documentElement), '::convertDomElementToArray() converts a \DomElement to an array');
|
|
}
|
|
|
|
public function testExtensions()
|
|
{
|
|
$container = new ContainerBuilder();
|
|
$container->registerExtension(new \ProjectExtension());
|
|
$container->registerExtension(new \ProjectWithXsdExtension());
|
|
$loader = new XmlFileLoader($container, new FileLocator(self::$fixturesPath.'/xml'));
|
|
|
|
// extension without an XSD
|
|
$loader->load('extensions/services1.xml');
|
|
$container->compile();
|
|
$services = $container->getDefinitions();
|
|
$parameters = $container->getParameterBag()->all();
|
|
|
|
$this->assertTrue(isset($services['project.service.bar']), '->load() parses extension elements');
|
|
$this->assertTrue(isset($parameters['project.parameter.bar']), '->load() parses extension elements');
|
|
|
|
$this->assertEquals('BAR', $services['project.service.foo']->getClass(), '->load() parses extension elements');
|
|
$this->assertEquals('BAR', $parameters['project.parameter.foo'], '->load() parses extension elements');
|
|
|
|
// extension with an XSD
|
|
$container = new ContainerBuilder();
|
|
$container->registerExtension(new \ProjectExtension());
|
|
$container->registerExtension(new \ProjectWithXsdExtension());
|
|
$loader = new XmlFileLoader($container, new FileLocator(self::$fixturesPath.'/xml'));
|
|
$loader->load('extensions/services2.xml');
|
|
$container->compile();
|
|
$services = $container->getDefinitions();
|
|
$parameters = $container->getParameterBag()->all();
|
|
|
|
$this->assertTrue(isset($services['project.service.bar']), '->load() parses extension elements');
|
|
$this->assertTrue(isset($parameters['project.parameter.bar']), '->load() parses extension elements');
|
|
|
|
$this->assertEquals('BAR', $services['project.service.foo']->getClass(), '->load() parses extension elements');
|
|
$this->assertEquals('BAR', $parameters['project.parameter.foo'], '->load() parses extension elements');
|
|
|
|
$container = new ContainerBuilder();
|
|
$container->registerExtension(new \ProjectExtension());
|
|
$container->registerExtension(new \ProjectWithXsdExtension());
|
|
$loader = new XmlFileLoader($container, new FileLocator(self::$fixturesPath.'/xml'));
|
|
|
|
// extension with an XSD (does not validate)
|
|
try {
|
|
$loader->load('extensions/services3.xml');
|
|
$this->fail('->load() throws an InvalidArgumentException if the configuration does not validate the XSD');
|
|
} catch (\Exception $e) {
|
|
$this->assertInstanceOf('Symfony\\Component\\DependencyInjection\\Exception\\InvalidArgumentException', $e, '->load() throws an InvalidArgumentException if the configuration does not validate the XSD');
|
|
$this->assertRegExp(sprintf('#^Unable to parse file ".+%s".$#', 'services3.xml'), $e->getMessage(), '->load() throws an InvalidArgumentException if the configuration does not validate the XSD');
|
|
|
|
$e = $e->getPrevious();
|
|
$this->assertInstanceOf('InvalidArgumentException', $e, '->load() throws an InvalidArgumentException if the configuration does not validate the XSD');
|
|
$this->assertContains('The attribute \'bar\' is not allowed', $e->getMessage(), '->load() throws an InvalidArgumentException if the configuration does not validate the XSD');
|
|
}
|
|
|
|
// non-registered extension
|
|
try {
|
|
$loader->load('extensions/services4.xml');
|
|
$this->fail('->load() throws an InvalidArgumentException if the tag is not valid');
|
|
} catch (\Exception $e) {
|
|
$this->assertInstanceOf('\InvalidArgumentException', $e, '->load() throws an InvalidArgumentException if the tag is not valid');
|
|
$this->assertStringStartsWith('There is no extension able to load the configuration for "project:bar" (in', $e->getMessage(), '->load() throws an InvalidArgumentException if the tag is not valid');
|
|
}
|
|
}
|
|
|
|
public function testExtensionInPhar()
|
|
{
|
|
if (extension_loaded('suhosin') && false === strpos(ini_get('suhosin.executor.include.whitelist'), 'phar')) {
|
|
$this->markTestSkipped('To run this test, add "phar" to the "suhosin.executor.include.whitelist" settings in your php.ini file.');
|
|
}
|
|
|
|
require_once self::$fixturesPath.'/includes/ProjectWithXsdExtensionInPhar.phar';
|
|
|
|
// extension with an XSD in PHAR archive
|
|
$container = new ContainerBuilder();
|
|
$container->registerExtension(new \ProjectWithXsdExtensionInPhar());
|
|
$loader = new XmlFileLoader($container, new FileLocator(self::$fixturesPath.'/xml'));
|
|
$loader->load('extensions/services6.xml');
|
|
|
|
// extension with an XSD in PHAR archive (does not validate)
|
|
try {
|
|
$loader->load('extensions/services7.xml');
|
|
$this->fail('->load() throws an InvalidArgumentException if the configuration does not validate the XSD');
|
|
} catch (\Exception $e) {
|
|
$this->assertInstanceOf('Symfony\\Component\\DependencyInjection\\Exception\\InvalidArgumentException', $e, '->load() throws an InvalidArgumentException if the configuration does not validate the XSD');
|
|
$this->assertRegExp(sprintf('#^Unable to parse file ".+%s".$#', 'services7.xml'), $e->getMessage(), '->load() throws an InvalidArgumentException if the configuration does not validate the XSD');
|
|
|
|
$e = $e->getPrevious();
|
|
$this->assertInstanceOf('InvalidArgumentException', $e, '->load() throws an InvalidArgumentException if the configuration does not validate the XSD');
|
|
$this->assertContains('The attribute \'bar\' is not allowed', $e->getMessage(), '->load() throws an InvalidArgumentException if the configuration does not validate the XSD');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @covers Symfony\Component\DependencyInjection\Loader\XmlFileLoader::supports
|
|
*/
|
|
public function testSupports()
|
|
{
|
|
$loader = new XmlFileLoader(new ContainerBuilder(), new FileLocator());
|
|
|
|
$this->assertTrue($loader->supports('foo.xml'), '->supports() returns true if the resource is loadable');
|
|
$this->assertFalse($loader->supports('foo.foo'), '->supports() returns true if the resource is loadable');
|
|
}
|
|
|
|
public function testNoNamingConflictsForAnonymousServices()
|
|
{
|
|
$container = new ContainerBuilder();
|
|
|
|
$loader1 = new XmlFileLoader($container, new FileLocator(self::$fixturesPath.'/xml/extension1'));
|
|
$loader1->load('services.xml');
|
|
$services = $container->getDefinitions();
|
|
$this->assertCount(2, $services, '->load() attributes unique ids to anonymous services');
|
|
$loader2 = new XmlFileLoader($container, new FileLocator(self::$fixturesPath.'/xml/extension2'));
|
|
$loader2->load('services.xml');
|
|
$services = $container->getDefinitions();
|
|
$this->assertCount(4, $services, '->load() attributes unique ids to anonymous services');
|
|
|
|
$services = $container->getDefinitions();
|
|
$args1 = $services['extension1.foo']->getArguments();
|
|
$inner1 = $services[(string) $args1[0]];
|
|
$this->assertEquals('BarClass1', $inner1->getClass(), '->load() uses the same configuration as for the anonymous ones');
|
|
$args2 = $services['extension2.foo']->getArguments();
|
|
$inner2 = $services[(string) $args2[0]];
|
|
$this->assertEquals('BarClass2', $inner2->getClass(), '->load() uses the same configuration as for the anonymous ones');
|
|
}
|
|
|
|
public function testDocTypeIsNotAllowed()
|
|
{
|
|
$container = new ContainerBuilder();
|
|
|
|
$loader = new XmlFileLoader($container, new FileLocator(self::$fixturesPath.'/xml'));
|
|
|
|
// document types are not allowed.
|
|
try {
|
|
$loader->load('withdoctype.xml');
|
|
$this->fail('->load() throws an InvalidArgumentException if the configuration contains a document type');
|
|
} catch (\Exception $e) {
|
|
$this->assertInstanceOf('Symfony\\Component\\DependencyInjection\\Exception\\InvalidArgumentException', $e, '->load() throws an InvalidArgumentException if the configuration contains a document type');
|
|
$this->assertRegExp(sprintf('#^Unable to parse file ".+%s".$#', 'withdoctype.xml'), $e->getMessage(), '->load() throws an InvalidArgumentException if the configuration contains a document type');
|
|
|
|
$e = $e->getPrevious();
|
|
$this->assertInstanceOf('InvalidArgumentException', $e, '->load() throws an InvalidArgumentException if the configuration contains a document type');
|
|
$this->assertSame('Document types are not allowed.', $e->getMessage(), '->load() throws an InvalidArgumentException if the configuration contains a document type');
|
|
}
|
|
}
|
|
|
|
public function testXmlNamespaces()
|
|
{
|
|
$container = new ContainerBuilder();
|
|
$loader = new XmlFileLoader($container, new FileLocator(self::$fixturesPath.'/xml'));
|
|
$loader->load('namespaces.xml');
|
|
$services = $container->getDefinitions();
|
|
|
|
$this->assertTrue(isset($services['foo']), '->load() parses <srv:service> elements');
|
|
$this->assertEquals(1, count($services['foo']->getTag('foo.tag')), '->load parses <srv:tag> elements');
|
|
$this->assertEquals(array(array('setBar', array('foo'))), $services['foo']->getMethodCalls(), '->load() parses the <srv:call> tag');
|
|
}
|
|
|
|
public function testLoadIndexedArguments()
|
|
{
|
|
$container = new ContainerBuilder();
|
|
$loader = new XmlFileLoader($container, new FileLocator(self::$fixturesPath.'/xml'));
|
|
$loader->load('services14.xml');
|
|
|
|
$this->assertEquals(array('index_0' => 'app'), $container->findDefinition('logger')->getArguments());
|
|
}
|
|
|
|
public function testLoadInlinedServices()
|
|
{
|
|
$container = new ContainerBuilder();
|
|
$loader = new XmlFileLoader($container, new FileLocator(self::$fixturesPath.'/xml'));
|
|
$loader->load('services21.xml');
|
|
|
|
$foo = $container->getDefinition('foo');
|
|
|
|
$fooFactory = $foo->getFactory();
|
|
$this->assertInstanceOf('Symfony\Component\DependencyInjection\Definition', $fooFactory[0]);
|
|
$this->assertSame('FooFactory', $fooFactory[0]->getClass());
|
|
$this->assertSame('createFoo', $fooFactory[1]);
|
|
|
|
$fooFactoryFactory = $fooFactory[0]->getFactory();
|
|
$this->assertInstanceOf('Symfony\Component\DependencyInjection\Definition', $fooFactoryFactory[0]);
|
|
$this->assertSame('Foobar', $fooFactoryFactory[0]->getClass());
|
|
$this->assertSame('createFooFactory', $fooFactoryFactory[1]);
|
|
|
|
$fooConfigurator = $foo->getConfigurator();
|
|
$this->assertInstanceOf('Symfony\Component\DependencyInjection\Definition', $fooConfigurator[0]);
|
|
$this->assertSame('Bar', $fooConfigurator[0]->getClass());
|
|
$this->assertSame('configureFoo', $fooConfigurator[1]);
|
|
|
|
$barConfigurator = $fooConfigurator[0]->getConfigurator();
|
|
$this->assertInstanceOf('Symfony\Component\DependencyInjection\Definition', $barConfigurator[0]);
|
|
$this->assertSame('Baz', $barConfigurator[0]->getClass());
|
|
$this->assertSame('configureBar', $barConfigurator[1]);
|
|
}
|
|
}
|