/** * @param string $id * @return string */ public function definitionClass(string $id) : string { if ($this->builder->hasAlias($id)) { return $this->builder->getDefinition((string) $this->builder->getAlias($id))->getClass()->getClass(); } return $this->builder->getDefinition($id)->getClass(); }
public function process( ContainerBuilder $container ) { if ( !$container->hasAlias( 'session.storage' ) ) { return; } $sessionStorageAlias = $container->getAlias( 'session.storage' ); $sessionStorageProxyDef = $container->findDefinition( 'ezpublish_legacy.session_storage_proxy' ); $sessionStorageProxyDef->replaceArgument( 1, new Reference( (string)$sessionStorageAlias ) ); $container->setAlias( 'session.storage', 'ezpublish_legacy.session_storage_proxy' ); if ( $container->hasAlias( 'session.handler' ) ) { $sessionHandlerAlias = $container->getAlias( 'session.handler' ); $interfaces = class_implements( $container->findDefinition( (string)$sessionHandlerAlias ) ); // Only swap session handler if it implements appropriate interface. if ( isset( $interfaces['SessionHandlerInterface'] ) ) { $sessionHandlerProxyDef = $container->findDefinition( 'ezpublish_legacy.session_handler_proxy' ); $sessionHandlerProxyDef->replaceArgument( 1, new Reference( (string)$sessionHandlerAlias ) ); $container->setAlias( 'session.handler', 'ezpublish_legacy.session_handler_proxy' ); } } }
public function testDriverIsAliased() { $config = ['driver' => 'doctrine']; $this->extension->load([$config], $this->container); $alias = $this->container->getAlias('bernard.driver'); $this->assertInstanceOf('Symfony\\Component\\DependencyInjection\\Alias', $alias); $this->assertEquals('bernard.driver.doctrine', (string) $alias); }
public function testSerializerServiceCanBeJmsSerializer() { $this->container->register('jms_serializer.serializer', 'JMS\\Serializer\\Serializer'); $this->container->register('serializer', 'JMS\\Serializer\\Serializer'); $compiler = new SerializerConfigurationPass(); $compiler->process($this->container); $this->assertSame('fos_rest.serializer.jms', (string) $this->container->getAlias('fos_rest.serializer')); }
public function process(ContainerBuilder $container) { // "query.max_query_count" is an array, it is only accessible // through "query" node and getting the "max_query_count" array // key with PHP. $query = $container->getParameter('liip_functional_test.query'); if (null === $query['max_query_count']) { $container->removeDefinition('liip_functional_test.query.count_client'); return; } if ($container->hasDefinition('test.client')) { // test.client is a definition. // Register it again as a private service to inject it as the parent $definition = $container->getDefinition('test.client'); $definition->setPublic(false); $container->setDefinition('liip_functional_test.query.count_client.parent', $definition); } elseif ($container->hasAlias('test.client')) { // test.client is an alias. // Register a private alias for this service to inject it as the parent $container->setAlias('liip_functional_test.query.count_client.parent', new Alias((string) $container->getAlias('test.client'), false)); } else { throw new \Exception('The LiipFunctionalTestBundle\'s Query Counter can only be used in the test environment.' . PHP_EOL . 'See https://github.com/liip/LiipFunctionalTestBundle#only-in-test-environment'); } $container->setAlias('test.client', 'liip_functional_test.query.count_client'); }
public function process(ContainerBuilder $container) { $definitions = new \SplPriorityQueue(); $order = PHP_INT_MAX; foreach ($container->getDefinitions() as $id => $definition) { if (!($decorated = $definition->getDecoratedService())) { continue; } $definitions->insert(array($id, $definition), array($decorated[2], --$order)); } foreach ($definitions as list($id, $definition)) { list($inner, $renamedId) = $definition->getDecoratedService(); $definition->setDecoratedService(null); if (!$renamedId) { $renamedId = $id . '.inner'; } // we create a new alias/service for the service we are replacing // to be able to reference it in the new one if ($container->hasAlias($inner)) { $alias = $container->getAlias($inner); $public = $alias->isPublic(); $container->setAlias($renamedId, new Alias((string) $alias, false)); } else { $definition = $container->getDefinition($inner); $public = $definition->isPublic(); $definition->setPublic(false); $container->setDefinition($renamedId, $definition); } $container->setAlias($inner, new Alias($id, $public)); } }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { $tags = $container->findTaggedServiceIds($this->tagName); foreach ($tags as $id => $tag) { /** @var Definition $serviceLinkDef */ $serviceLinkDef = $container->getDefinition($id); if (!isset($tag[0]['service'])) { throw new InvalidArgumentException(sprintf('Tag "%s" for service "%s" does not have required param "service"', $this->tagName, $id)); } $serviceId = $tag[0]['service']; $isOptional = false; if (strpos($serviceId, '?') === 0) { $serviceId = substr($serviceId, 1); $isOptional = true; } if ($container->hasDefinition($serviceId)) { // the service we are referring to must be public $serviceDef = $container->getDefinition($serviceId); if (!$serviceDef->isPublic()) { $serviceDef->setPublic(true); } } elseif ($container->hasAlias($serviceId)) { // the service alias we are referring to must be public $serviceAlias = $container->getAlias($serviceId); if (!$serviceAlias->isPublic()) { $serviceAlias->setPublic(true); } } elseif (!$isOptional) { throw new InvalidArgumentException(sprintf('Target service "%s" is undefined. The service link "%s" with tag "%s" and tag-service "%s"', $serviceId, $id, $this->tagName, $serviceId)); } $serviceLinkDef->setClass($this->decoratorClass)->setPublic(false)->setArguments([new Reference('service_container'), $serviceId, $isOptional]); } }
/** * You can modify the container here before it is dumped to PHP code. * * @param ContainerBuilder $container * * @api */ public function process(ContainerBuilder $container) { $config = $container->getParameter(ElastificationPhpClientExtension::PARAMETER_CONFIG_KEY); if (true === $config['profiler_enabled']) { $clientAlias = $container->getAlias(ElastificationPhpClientExtension::ALIAS_CLIENT); $profilerDef = $container->getDefinition(ElastificationPhpClientExtension::SERVICE_CLIENT_PROFILER_KEY); $profilerDef->replaceArgument(0, new Reference($clientAlias->__toString())); $dataCollectorDef = $container->getDefinition('elastification_php_client.datacollector'); $dataCollectorDef->addMethodCall('setConfig', array($config)); $container->setAlias(ElastificationPhpClientExtension::ALIAS_CLIENT, ElastificationPhpClientExtension::SERVICE_CLIENT_PROFILER_KEY); } else { if ($container->hasDefinition('profiler')) { $sfProfilerDef = $container->getDefinition('profiler'); $sfProfilerMethodCalls = $sfProfilerDef->getMethodCalls(); foreach ($sfProfilerMethodCalls as $sfProfilerMethodCallsIndex => $sfProfilerMethodCall) { if (isset($sfProfilerMethodCall[1][0]) && 'elastification_php_client.datacollector' == (string) $sfProfilerMethodCall[1][0]) { unset($sfProfilerMethodCalls[$sfProfilerMethodCallsIndex]); } } $sfProfilerDef->setMethodCalls($sfProfilerMethodCalls); } $container->removeDefinition(ElastificationPhpClientExtension::SERVICE_CLIENT_PROFILER_KEY); $container->removeDefinition('elastification_php_client.datacollector'); } }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { $tags = $container->findTaggedServiceIds(self::TAG_NAME); foreach ($tags as $id => $tag) { /** @var Definition $serviceLinkDef */ $serviceLinkDef = $container->getDefinition($id); if (!isset($tag[0]['service'])) { throw new RuntimeException(sprintf('Tag "%s" for service "%s" does not have required param "service"', self::TAG_NAME, $id)); } $serviceId = $tag[0]['service']; $isOptional = false; if (strpos($serviceId, '?') === 0) { $serviceId = substr($serviceId, 1); $isOptional = true; } if ($container->hasDefinition($serviceId)) { // the service we are referring to must be public $serviceDef = $container->getDefinition($serviceId); if (!$serviceDef->isPublic()) { $serviceDef->setPublic(true); } } elseif ($container->hasAlias($serviceId)) { // the service alias we are referring to must be public $serviceAlias = $container->getAlias($serviceId); if (!$serviceAlias->isPublic()) { $serviceAlias->setPublic(true); } } elseif (!$isOptional) { throw new RuntimeException(sprintf('Target service "%s" is undefined. The service link "%s" with tag "%s" and tag-service "%s"', $serviceId, $id, self::TAG_NAME, $serviceId)); } $serviceLinkDef->setClass('Oro\\Bundle\\EntityConfigBundle\\DependencyInjection\\Utils\\ServiceLink')->setPublic(false)->setArguments([new Reference('service_container'), $serviceId, $isOptional]); } }
/** * @see Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface::process() */ public function process(ContainerBuilder $container) { if (!$container->hasDefinition('foq_elastica.provider_registry')) { return; } // Infer the default index name from the service alias $defaultIndex = substr($container->getAlias('foq_elastica.index'), 19); $registry = $container->getDefinition('foq_elastica.provider_registry'); $providers = $container->findTaggedServiceIds('foq_elastica.provider'); foreach ($providers as $providerId => $tags) { $index = $type = null; $class = $container->getDefinition($providerId)->getClass(); if (!$class || !$this->isProviderImplementation($class)) { throw new \InvalidArgumentException(sprintf('Elastica provider "%s" with class "%s" must implement ProviderInterface.', $providerId, $class)); } foreach ($tags as $tag) { if (!isset($tag['type'])) { throw new \InvalidArgumentException(sprintf('Elastica provider "%s" must specify the "type" attribute.', $providerId)); } $index = isset($tag['index']) ? $tag['index'] : $defaultIndex; $type = $tag['type']; } $registry->addMethodCall('addProvider', array($index, $type, $providerId)); } }
/** * @dataProvider getObjectManagerConfigurationTestData * * @param string $expectedModelManagerName * @param string $expectedObjectManager * @param array $configs * @param string $message */ public function testObjectManagerConfiguration($expectedModelManagerName, $expectedObjectManager, $configs, $message = '') { $this->extension->load($configs, $this->container); $alias = $this->container->getAlias('ivoaz_content_editable.object_manager'); $modelManagerName = $this->container->getParameter('ivoaz_content_editable.model_manager_name'); $this->assertEquals($expectedObjectManager, $alias, $message); $this->assertEquals($expectedModelManagerName, $modelManagerName, $message); }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { $alias = $container->getAlias('spy_timeline.spread.deployer'); $spreadDeployer = $container->getDefinition((string) $alias); foreach ($container->findTaggedServiceIds('spy_timeline.spread') as $id => $tags) { $spreadDeployer->addMethodCall('addSpread', array($container->getDefinition($id))); } }
public function process(\Symfony\Component\DependencyInjection\ContainerBuilder $container) { //Backward compatibility with Fos User 1.3 if (class_exists('FOS\\UserBundle\\FOSUserEvents')) { $fosUserListenerFlash = new \Symfony\Component\DependencyInjection\Definition(); $fosUserListenerFlash->setClass('Tecnocreaciones\\Bundle\\AjaxFOSUserBundle\\EventListener\\FlashListener')->addArgument($container->getDefinition('session'))->addArgument($container->getAlias('translator'))->setTags(array('kernel.event_subscriber')); } }
public function loadInternal(array $config, ContainerBuilder $container) { $loader = new XmlFileLoader($container, new FileLocator(array(__DIR__ . '/../Resources/config/'))); $loader->load('services.xml'); // Built-in handlers. $container->getDefinition('jms_serializer.datetime_handler')->addArgument($config['handlers']['datetime']['default_format'])->addArgument($config['handlers']['datetime']['default_timezone']); // property naming $container->getDefinition('jms_serializer.camel_case_naming_strategy')->addArgument($config['property_naming']['separator'])->addArgument($config['property_naming']['lower_case']); if ($config['property_naming']['enable_cache']) { $container->getDefinition('jms_serializer.cache_naming_strategy')->addArgument(new Reference((string) $container->getAlias('jms_serializer.naming_strategy'))); $container->setAlias('jms_serializer.naming_strategy', 'jms_serializer.cache_naming_strategy'); } $bundles = $container->getParameter('kernel.bundles'); // metadata if ('none' === $config['metadata']['cache']) { $container->removeAlias('jms_serializer.metadata.cache'); } elseif ('file' === $config['metadata']['cache']) { $container->getDefinition('jms_serializer.metadata.cache.file_cache')->replaceArgument(0, $config['metadata']['file_cache']['dir']); $dir = $container->getParameterBag()->resolveValue($config['metadata']['file_cache']['dir']); if (!file_exists($dir)) { if (!($rs = @mkdir($dir, 0777, true))) { throw new RuntimeException(sprintf('Could not create cache directory "%s".', $dir)); } } } else { $container->setAlias('jms_serializer.metadata.cache', new Alias($config['metadata']['cache'], false)); } if ($config['metadata']['infer_types_from_doctrine_metadata'] && isset($bundles['DoctrineBundle'])) { $container->setAlias('jms_serializer.metadata_driver', 'jms_serializer.metadata.doctrine_type_driver'); } $container->getDefinition('jms_serializer.metadata_factory')->replaceArgument(2, $config['metadata']['debug']); // directories $directories = array(); if ($config['metadata']['auto_detection']) { foreach ($bundles as $name => $class) { $ref = new \ReflectionClass($class); $directories[$ref->getNamespaceName()] = dirname($ref->getFileName()) . '/Resources/config/serializer'; } } foreach ($config['metadata']['directories'] as $directory) { $directory['path'] = rtrim(str_replace('\\', '/', $directory['path']), '/'); if ('@' === $directory['path'][0]) { $bundleName = substr($directory['path'], 1, strpos($directory['path'], '/') - 1); if (!isset($bundles[$bundleName])) { throw new RuntimeException(sprintf('The bundle "%s" has not been registered with AppKernel. Available bundles: %s', $bundleName, implode(', ', array_keys($bundles)))); } $ref = new \ReflectionClass($bundles[$bundleName]); $directory['path'] = dirname($ref->getFileName()) . substr($directory['path'], strlen('@' . $bundleName)); } $directories[rtrim($directory['namespace_prefix'], '\\')] = rtrim($directory['path'], '\\/'); } $container->getDefinition('jms_serializer.metadata.file_locator')->replaceArgument(0, $directories); $container->setParameter('jms_serializer.xml_deserialization_visitor.doctype_whitelist', $config['visitors']['xml']['doctype_whitelist']); $container->setParameter('jms_serializer.json_serialization_visitor.options', $config['visitors']['json']['options']); if (!$config['enable_short_alias']) { $container->removeAlias('serializer'); } }
private function enableUserinfoSignature(ContainerBuilder $container) { $definition = $container->getDefinition('oauth2_server.openid_connect.userinfo_endpoint'); $jwt_creator = new Reference('jose.jwt_creator.openid_connect'); $issuer = $container->getParameter('oauth2_server.openid_connect.userinfo_endpoint.signature.issuer'); $signature_algorithm = $container->getParameter('oauth2_server.openid_connect.userinfo_endpoint.signature.signature_algorithm'); $signature_key_set = new Reference($container->getAlias('oauth2_server.openid_connect.userinfo_endpoint.signature.signature_key_set')); $definition->addMethodCall('enableSignedResponsesSupport', [$jwt_creator, $issuer, $signature_algorithm, $signature_key_set]); }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { $processors = $container->findTaggedServiceIds('knp_rad_fixtures_load.processor'); $alias = $container->getAlias('knp_rad_fixtures_load.fixtures_factory'); $factory = $container->getDefinition($alias); foreach ($processors as $id => $tags) { $factory->addMethodCall('addProcessor', [new Reference($id)]); } }
/** * @test */ public function it_adds_api_services_to_the_container() { $configuration = $this->minConfiguration; $this->extension->load(array($configuration), $this->container); $apiServiceId = 'devhelp_piwik.api.frontend'; /** * has definition for the registered instance */ $this->assertTrue($this->container->hasDefinition($apiServiceId)); /** * aliases default api (first registered) */ $this->assertSame($apiServiceId, (string) $this->container->getAlias('devhelp_piwik.api')); /** * aliases default api as well */ $this->assertSame($apiServiceId, (string) $this->container->getAlias('devhelp_piwik.api.default')); }
public function testCustomEntityManager() { /** * Create entity manager service */ $this->containerBuilder->setDefinition('my_custom_entity_manager', new Definition('App\MyEntityManager')); $loader = new SparklingAdyenExtension(); $config = $this->getDefaultConfig(); $config['orm_entity_manager'] = 'my_custom_entity_manager'; $loader->load(array($config), $this->containerBuilder); $this->containerBuilder->compile(); $definition = $this->containerBuilder->getAlias('adyen.orm_entity_manager'); $this->assertEquals('my_custom_entity_manager', $definition->__toString()); }
/** * @inheritDoc */ public function process(ContainerBuilder $container) { if (!$container->getParameter('vesax.ajax_cross_domain_session.config.enabled')) { return; } $sessionStorageDecorator = new Definition('Vesax\\AjaxCrossDomainSessionBundle\\SessionStorage\\QueryIdSessionStorageDecorator', [new Reference($container->getAlias(self::ALIAS_NAME)), new Parameter('vesax.ajax_cross_domain_session.config.parameter')]); $sessionStorageDecorator->addTag('kernel.event_listener', ['event' => 'kernel.response', 'method' => 'onResponse']); $container->setDefinition(self::DECORATOR_NAME, $sessionStorageDecorator); $container->setAlias(self::ALIAS_NAME, self::DECORATOR_NAME); }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { foreach (array_keys($container->findTaggedServiceIds('lug.resource')) as $service) { $resource = $container->getDefinition($service)->getArgument(0); $manager = $container->getDefinition((string) $container->getAlias('lug.manager.' . $resource)); if (!$manager->hasTag($tag = 'lug.manager')) { $manager->addTag($tag, ['resource' => $resource]); } } }
/** * Returns the definition of the provided service. * * This method also resolves aliases. * * @param ContainerBuilder $container * @param string $id * @return \Symfony\Component\DependencyInjection\Definition|null */ protected function getDefinition(ContainerBuilder $container, $id) { while ($container->hasAlias($id)) { $id = (string) $container->getAlias($id); } if (!$container->hasDefinition($id)) { return null; } return $container->getDefinition($id); }
/** * @param ContainerBuilder $container */ public function process(ContainerBuilder $container) { // Replace default router if ($container->hasAlias('router')) { // Set parent router $container->findDefinition('genedys_csrf_route.routing.router')->addMethodCall('setParentRouter', [new Reference((string) $container->getAlias('router'))]); // Update alias $container->setAlias('router', 'genedys_csrf_route.routing.router'); } // Replace Sensio Route annotation loader $container->findDefinition('sensio_framework_extra.routing.loader.annot_class')->setClass('%genedys_csrf_route.routing.loader.class%'); }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { $id = 'fos_rest.view_handler'; if (!$container->hasDefinition($id)) { if (!$container->hasAlias($id)) { return; } $id = $container->getAlias($id); } $definition = $container->getDefinition($id); $definition->addMethodCall('registerHandler', ['csv', [new Reference('sulu_core.rest.view_handler.csv'), 'createResponse']]); }
/** * @param ContainerBuilder $container */ public function process(ContainerBuilder $container) { if (!$container->getParameter('happyr_deferred_event_simple_bus_enabled')) { return; } $alias = 'simple_bus.asynchronous.message_serializer'; $happyrMessageSerializer = 'happyr.deferred_event_simple_bus.service.message_serializer'; $simpleBusMessageSerializerId = $container->getAlias($alias)->__toString(); $definition = $container->getDefinition($happyrMessageSerializer); $definition->replaceArgument(0, new Reference($simpleBusMessageSerializerId)); $container->setAlias($alias, $happyrMessageSerializer); }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { if (!$container->hasDefinition('oauth2_server.jwt_bearer_grant_type')) { return; } $definition = $container->getDefinition('oauth2_server.jwt_bearer_grant_type'); $issue_refresh_token = $container->getParameter('oauth2_server.jwt_bearer_grant_type.issue_refresh_token'); $definition->addMethodCall(sprintf('%sRefreshTokenIssuanceWithAccessToken', $issue_refresh_token ? 'enable' : 'disable')); if (true === $container->getParameter('oauth2_server.jwt_bearer_grant_type.encryption.enabled')) { $definition->addMethodCall('enableEncryptedAssertions', [$container->getParameter('oauth2_server.jwt_bearer_grant_type.encryption.required'), new Reference($container->getAlias('oauth2_server.jwt_bearer_grant_type.encryption.key_set'))]); } }
/** * Given an array of service IDs, this returns the array of corresponding * Definition and Alias objects that those ids represent. * * @param string $serviceId The service id to resolve * * @return Definition|Alias */ protected function resolveServiceDefinition($serviceId) { if ($this->containerBuilder->hasDefinition($serviceId)) { return $this->containerBuilder->getDefinition($serviceId); } // Some service IDs don't have a Definition, they're simply an Alias if ($this->containerBuilder->hasAlias($serviceId)) { return $this->containerBuilder->getAlias($serviceId); } // the service has been injected in some special way, just return the service return $this->containerBuilder->get($serviceId); }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { if (!$container->hasAlias('oauth2_server.core.access_token_manager')) { return; } $alias = $container->getAlias('oauth2_server.core.access_token_manager'); $definition = $container->getDefinition($alias); $taggedServices = $container->findTaggedServiceIds('oauth2_server.access_token_updater'); foreach ($taggedServices as $id => $attributes) { $definition->addMethodCall('addTokenUpdater', [new Reference($id)]); } }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { if (!$container->hasDefinition('oauth2_server.client_registration_endpoint') || !$container->hasDefinition('oauth2_server.client_configuration_endpoint')) { return; } $client_registration_endpoint = $container->getDefinition('oauth2_server.client_registration_endpoint'); $client_configuration_endpoint = $container->getDefinition('oauth2_server.client_configuration_endpoint'); if (true === $container->getParameter('oauth2_server.initial_access_token.enabled')) { $client_registration_endpoint->addMethodCall('enableInitialAccessTokenSupport', [new Reference($container->getAlias('oauth2_server.initial_access_token.manager'))]); $is_initial_access_token_required = $container->getParameter('oauth2_server.initial_access_token.required'); $method = sprintf('%sallowRegistrationWithoutInitialAccessToken', $is_initial_access_token_required ? 'dis' : ''); $client_registration_endpoint->addMethodCall($method, []); } if (true === $container->getParameter('oauth2_server.software_statement.enabled')) { $client_registration_endpoint->addMethodCall('enableSoftwareStatementSupport', [new Reference('jose.jwt_loader.oauth2_server_software_statement'), new Reference($container->getAlias('oauth2_server.software_statement.key_set'))]); $client_configuration_endpoint->addMethodCall('enableSoftwareStatementSupport', [new Reference('jose.jwt_loader.oauth2_server_software_statement'), new Reference($container->getAlias('oauth2_server.software_statement.key_set'))]); $is_software_statement_required = $container->getParameter('oauth2_server.software_statement.required'); $method = sprintf('%sallowRegistrationWithoutSoftwareStatement', $is_software_statement_required ? 'dis' : ''); $client_registration_endpoint->addMethodCall($method, []); $client_configuration_endpoint->addMethodCall($method, []); } }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { if (!$container->hasDefinition('oauth2_server.token_endpoint_auth_method.client_assertion_jwt')) { return; } if (!$container->getParameter('oauth2_server.token_endpoint_auth_method.client_assertion_jwt.encryption.enabled')) { return; } $definition = $container->getDefinition('oauth2_server.token_endpoint_auth_method.client_assertion_jwt'); $is_encryption_required = $container->getParameter('oauth2_server.token_endpoint_auth_method.client_assertion_jwt.encryption.required'); $encryption_jwk_set = $container->getAlias('oauth2_server.token_endpoint_auth_method.client_assertion_jwt.encryption.key_set'); $definition->addMethodCall('enableEncryptedAssertions', [$is_encryption_required, new Reference($encryption_jwk_set)]); }
public function testSwiftMailerConfigurationLoad() { $extension = new LtRedisExtension(); $parser = new Parser(); $config = $parser->parse($this->swiftmailerYmlConfig()); $extension->load(array($config), $container = new ContainerBuilder()); $this->assertTrue($container->hasDefinition('lt_redis.swiftmailer.spool')); $this->assertTrue($container->hasDefinition('lt_redis.swiftmailer')); $this->assertTrue($container->getDefinition('lt_redis.swiftmailer.spool')->hasMethodCall('setRedis')); $this->assertTrue($container->getDefinition('lt_redis.swiftmailer.spool')->hasMethodCall('setKey')); $this->assertTrue($container->hasAlias('swiftmailer.spool')); $this->assertEquals($container->getAlias('swiftmailer.spool'), 'lt_redis.swiftmailer.spool'); }