/**
* @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');
}
