From 19f371a6b5c85491c35077ab8c17e0ac5e80d3b3 Mon Sep 17 00:00:00 2001
From: Maksim Kotlyar <kotlyar.maksim@gmail.com>
Date: Sun, 9 Feb 2014 12:58:40 +0200
Subject: [PATCH] Add WebPathResolverFactory, AwsS3ResolverFactory,
 StreamLoaderFactory and docs.

---
 DependencyInjection/Configuration.php         |  71 ++++-
 .../Factory/Loader/LoaderFactoryInterface.php |  33 +++
 .../Factory/Loader/StreamLoaderFactory.php    |  57 ++++
 .../Factory/Resolver/AwsS3ResolverFactory.php |  83 ++++++
 .../Resolver/ResolverFactoryInterface.php     |  33 +++
 .../Resolver/WebPathResolverFactory.php       |  50 ++++
 DependencyInjection/LiipImagineExtension.php  |  72 +++++-
 LiipImagineBundle.php                         |  13 +-
 README.md                                     |   5 +
 Resources/config/imagine.xml                  |  25 +-
 Resources/doc/cache-resolver/aws_s3.md        |  45 ++--
 Resources/doc/cache-resolver/web_path.md      |  18 ++
 Resources/doc/cache-resolvers.md              |   1 +
 Resources/doc/data-loader/stream.md           |  23 +-
 .../DependencyInjection/ConfigurationTest.php | 178 +++++++++++++
 .../Loader/StreamLoaderFactoryTest.php        | 121 +++++++++
 .../Resolver/AwsS3ResolverFactoryTest.php     | 243 ++++++++++++++++++
 .../Resolver/WebPathResolverFactoryTest.php   | 107 ++++++++
 .../LiipImagineExtensionTest.php              |   6 +-
 .../Cache/Resolver/WebPathResolverTest.php    |  21 --
 .../S8rrlhhQ/images/cats.jpeg                 | Bin 0 -> 2833 bytes
 Tests/LiipImagineBundleTest.php               | 122 +++++++++
 22 files changed, 1266 insertions(+), 61 deletions(-)
 create mode 100644 DependencyInjection/Factory/Loader/LoaderFactoryInterface.php
 create mode 100644 DependencyInjection/Factory/Loader/StreamLoaderFactory.php
 create mode 100644 DependencyInjection/Factory/Resolver/AwsS3ResolverFactory.php
 create mode 100644 DependencyInjection/Factory/Resolver/ResolverFactoryInterface.php
 create mode 100644 DependencyInjection/Factory/Resolver/WebPathResolverFactory.php
 create mode 100644 Resources/doc/cache-resolver/web_path.md
 create mode 100644 Tests/DependencyInjection/ConfigurationTest.php
 create mode 100644 Tests/DependencyInjection/Factory/Loader/StreamLoaderFactoryTest.php
 create mode 100644 Tests/DependencyInjection/Factory/Resolver/AwsS3ResolverFactoryTest.php
 create mode 100644 Tests/DependencyInjection/Factory/Resolver/WebPathResolverFactoryTest.php
 delete mode 100644 Tests/Functional/Imagine/Cache/Resolver/WebPathResolverTest.php
 create mode 100644 Tests/Functional/app/web/media/cache/thumbnail_web_path/S8rrlhhQ/images/cats.jpeg
 create mode 100644 Tests/LiipImagineBundleTest.php

diff --git a/DependencyInjection/Configuration.php b/DependencyInjection/Configuration.php
index b71d9f3a1..a23d193a3 100644
--- a/DependencyInjection/Configuration.php
+++ b/DependencyInjection/Configuration.php
@@ -2,21 +2,58 @@
 
 namespace Liip\ImagineBundle\DependencyInjection;
 
+use Liip\ImagineBundle\DependencyInjection\Factory\Loader\LoaderFactoryInterface;
+use Liip\ImagineBundle\DependencyInjection\Factory\Resolver\ResolverFactoryInterface;
+use Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition;
 use Symfony\Component\Config\Definition\Builder\TreeBuilder;
 use Symfony\Component\Config\Definition\ConfigurationInterface;
 
 class Configuration implements ConfigurationInterface
 {
     /**
-     * Generates the configuration tree.
-     *
-     * @return TreeBuilder
+     * @var ResolverFactoryInterface[]
+     */
+    protected $resolversFactories;
+
+    /**
+     * @var LoaderFactoryInterface[]
+     */
+    protected $loadersFactories;
+
+    /**
+     * @param ResolverFactoryInterface[] $resolversFactories
+     * @param LoaderFactoryInterface[] $loadersFactories
+     */
+    public function __construct(array $resolversFactories, array $loadersFactories)
+    {
+        $this->resolversFactories = $resolversFactories;
+        $this->loadersFactories = $loadersFactories;
+    }
+
+    /**
+     * {@inheritDoc}
      */
     public function getConfigTreeBuilder()
     {
         $treeBuilder = new TreeBuilder();
         $rootNode = $treeBuilder->root('liip_imagine', 'array');
 
+        $resolversPrototypeNode = $rootNode
+            ->children()
+                ->arrayNode('resolvers')
+                    ->useAttributeAsKey('name')
+                    ->prototype('array')
+        ;
+        $this->addResolversSections($resolversPrototypeNode);
+
+        $loadersPrototypeNode = $rootNode
+            ->children()
+                ->arrayNode('loaders')
+                    ->useAttributeAsKey('name')
+                    ->prototype('array')
+        ;
+        $this->addLoadersSections($loadersPrototypeNode);
+
         $rootNode
             ->fixXmlConfig('format', 'formats')
             ->fixXmlConfig('filter_set', 'filter_sets')
@@ -27,10 +64,8 @@ public function getConfigTreeBuilder()
                         ->thenInvalid('Invalid imagine driver specified: %s')
                     ->end()
                 ->end()
-                ->scalarNode('web_root')->defaultValue('%kernel.root_dir%/../web')->end()
                 ->scalarNode('data_root')->defaultValue('%liip_imagine.web_root%')->end()
-                ->scalarNode('cache_prefix')->defaultValue('/media/cache')->end()
-                ->scalarNode('cache')->defaultValue('web_path')->end()
+                ->scalarNode('cache')->defaultValue('default')->end()
                 ->scalarNode('cache_base_path')->defaultValue('')->end()
                 ->scalarNode('data_loader')->defaultValue('filesystem')->end()
                 ->scalarNode('controller_action')->defaultValue('liip_imagine.controller:filterAction')->end()
@@ -71,4 +106,28 @@ public function getConfigTreeBuilder()
 
         return $treeBuilder;
     }
+
+    /**
+     * @param ArrayNodeDefinition $resolversPrototypeNode
+     */
+    protected function addResolversSections(ArrayNodeDefinition $resolversPrototypeNode)
+    {
+        foreach ($this->resolversFactories as $factory) {
+            $factory->addConfiguration(
+                $resolversPrototypeNode->children()->arrayNode($factory->getName())
+            );
+        }
+    }
+
+    /**
+     * @param ArrayNodeDefinition $resolversPrototypeNode
+     */
+    protected function addLoadersSections(ArrayNodeDefinition $resolversPrototypeNode)
+    {
+        foreach ($this->loadersFactories as $factory) {
+            $factory->addConfiguration(
+                $resolversPrototypeNode->children()->arrayNode($factory->getName())
+            );
+        }
+    }
 }
diff --git a/DependencyInjection/Factory/Loader/LoaderFactoryInterface.php b/DependencyInjection/Factory/Loader/LoaderFactoryInterface.php
new file mode 100644
index 000000000..af58b2855
--- /dev/null
+++ b/DependencyInjection/Factory/Loader/LoaderFactoryInterface.php
@@ -0,0 +1,33 @@
+<?php
+
+namespace Liip\ImagineBundle\DependencyInjection\Factory\Loader;
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition;
+
+interface LoaderFactoryInterface
+{
+    /**
+     * @param ContainerBuilder $container
+     * @param string           $loaderName
+     * @param array            $config
+     *
+     * @return string The resolver service id
+     */
+    public function create(ContainerBuilder $container, $loaderName, array $config);
+
+    /**
+     * The resolver factory name,
+     * For example filesystem, stream
+     *
+     * @return string
+     */
+    public function getName();
+
+    /**
+     * @param ArrayNodeDefinition $builder
+     *
+     * @return void
+     */
+    public function addConfiguration(ArrayNodeDefinition $builder);
+}
diff --git a/DependencyInjection/Factory/Loader/StreamLoaderFactory.php b/DependencyInjection/Factory/Loader/StreamLoaderFactory.php
new file mode 100644
index 000000000..7d050a7f4
--- /dev/null
+++ b/DependencyInjection/Factory/Loader/StreamLoaderFactory.php
@@ -0,0 +1,57 @@
+<?php
+/**
+ * Created by PhpStorm.
+ * User: makasim
+ * Date: 2/21/14
+ * Time: 4:44 PM
+ */
+
+namespace Liip\ImagineBundle\DependencyInjection\Factory\Loader;
+
+
+use Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\DefinitionDecorator;
+
+class StreamLoaderFactory implements LoaderFactoryInterface
+{
+    /**
+     * {@inheritDoc}
+     */
+    public function create(ContainerBuilder $container, $loaderName, array $config)
+    {
+        $loaderDefinition = new DefinitionDecorator('liip_imagine.data.loader.prototype.stream');
+        $loaderDefinition->replaceArgument(0, $config['wrapper']);
+        $loaderDefinition->replaceArgument(1, $config['context']);
+        $loaderDefinition->addTag('liip_imagine.data.loader', array(
+            'loader' => $loaderName
+        ));
+        $loaderId = 'liip_imagine.data.loader.'.$loaderName;
+
+        $container->setDefinition($loaderId, $loaderDefinition);
+
+        return $loaderId;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getName()
+    {
+        return 'stream';
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function addConfiguration(ArrayNodeDefinition $builder)
+    {
+        $builder
+            ->addDefaultsIfNotSet()
+            ->children()
+                ->scalarNode('wrapper')->isRequired()->cannotBeEmpty()->end()
+                ->scalarNode('context')->defaultValue(null)->end()
+            ->end()
+        ;
+    }
+}
diff --git a/DependencyInjection/Factory/Resolver/AwsS3ResolverFactory.php b/DependencyInjection/Factory/Resolver/AwsS3ResolverFactory.php
new file mode 100644
index 000000000..073b962f5
--- /dev/null
+++ b/DependencyInjection/Factory/Resolver/AwsS3ResolverFactory.php
@@ -0,0 +1,83 @@
+<?php
+
+namespace Liip\ImagineBundle\DependencyInjection\Factory\Resolver;
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\DefinitionDecorator;
+use Symfony\Component\DependencyInjection\Reference;
+
+class AwsS3ResolverFactory implements ResolverFactoryInterface
+{
+    /**
+     * {@inheritDoc}
+     */
+    public function create(ContainerBuilder $container, $resolverName, array $config)
+    {
+        $awsS3ClientDefinition =  new Definition('Aws\S3\S3Client');
+        $awsS3ClientDefinition->setFactoryClass('Aws\S3\S3Client');
+        $awsS3ClientDefinition->setFactoryMethod('factory');
+        $awsS3ClientDefinition->addArgument($config['client_config']);
+        $awsS3ClientId = 'liip_imagine.cache.resolver.'.$resolverName.'.client';
+        $container->setDefinition($awsS3ClientId, $awsS3ClientDefinition);
+
+        $resolverDefinition = new DefinitionDecorator('liip_imagine.cache.resolver.prototype.aws_s3');
+        $resolverDefinition->replaceArgument(0, new Reference($awsS3ClientId));
+        $resolverDefinition->replaceArgument(1, $config['bucket']);
+        $resolverDefinition->replaceArgument(2, $config['acl']);
+        $resolverDefinition->replaceArgument(3, $config['url_options']);
+        $resolverId = 'liip_imagine.cache.resolver.'.$resolverName;
+        $container->setDefinition($resolverId, $resolverDefinition);
+
+        if ($config['cache']) {
+            $internalResolverId = 'liip_imagine.cache.resolver.'.$resolverName.'.internal';
+
+            $container->setDefinition($internalResolverId, $resolverDefinition);
+
+            $cacheResolverDefinition = new DefinitionDecorator('liip_imagine.cache.resolver.prototype.cache');
+            $cacheResolverDefinition->replaceArgument(0, new Reference($config['cache']));
+            $cacheResolverDefinition->replaceArgument(1, new Reference($internalResolverId));
+
+            $container->setDefinition($resolverId, $cacheResolverDefinition);
+        }
+
+        $container->getDefinition($resolverId)->addTag('liip_imagine.cache.resolver', array(
+            'resolver' => $resolverName
+        ));
+
+        return $resolverId;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getName()
+    {
+        return 'aws_s3';
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function addConfiguration(ArrayNodeDefinition $builder)
+    {
+        $builder
+            ->addDefaultsIfNotSet()
+            ->children()
+                ->scalarNode('bucket')->isRequired()->cannotBeEmpty()->end()
+                ->scalarNode('cache')->defaultValue(false)->end()
+                ->scalarNode('acl')->defaultValue('public-read')->cannotBeEmpty()->end()
+                ->arrayNode('client_config')
+                    ->isRequired()
+                    ->useAttributeAsKey('key')
+                    ->prototype('scalar')->end()
+                ->end()
+                ->arrayNode('url_options')
+                    ->useAttributeAsKey('key')
+                    ->prototype('scalar')->end()
+                ->end()
+            ->end()
+        ;
+    }
+}
diff --git a/DependencyInjection/Factory/Resolver/ResolverFactoryInterface.php b/DependencyInjection/Factory/Resolver/ResolverFactoryInterface.php
new file mode 100644
index 000000000..b1ac375b9
--- /dev/null
+++ b/DependencyInjection/Factory/Resolver/ResolverFactoryInterface.php
@@ -0,0 +1,33 @@
+<?php
+
+namespace Liip\ImagineBundle\DependencyInjection\Factory\Resolver;
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition;
+
+interface ResolverFactoryInterface
+{
+    /**
+     * @param ContainerBuilder $container
+     * @param string           $resolverName
+     * @param array            $config
+     *
+     * @return string The resolver service id
+     */
+    public function create(ContainerBuilder $container, $resolverName, array $config);
+
+    /**
+     * The resolver factory name,
+     * For example web_path, aws_s3 o amazon_s3
+     *
+     * @return string
+     */
+    public function getName();
+
+    /**
+     * @param ArrayNodeDefinition $builder
+     *
+     * @return void
+     */
+    public function addConfiguration(ArrayNodeDefinition $builder);
+}
diff --git a/DependencyInjection/Factory/Resolver/WebPathResolverFactory.php b/DependencyInjection/Factory/Resolver/WebPathResolverFactory.php
new file mode 100644
index 000000000..899f43191
--- /dev/null
+++ b/DependencyInjection/Factory/Resolver/WebPathResolverFactory.php
@@ -0,0 +1,50 @@
+<?php
+
+namespace Liip\ImagineBundle\DependencyInjection\Factory\Resolver;
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition;
+use Symfony\Component\DependencyInjection\DefinitionDecorator;
+
+class WebPathResolverFactory implements ResolverFactoryInterface
+{
+    /**
+     * {@inheritDoc}
+     */
+    public function create(ContainerBuilder $container, $resolverName, array $config)
+    {
+        $resolverDefinition = new DefinitionDecorator('liip_imagine.cache.resolver.prototype.web_path');
+        $resolverDefinition->replaceArgument(2, $config['web_root']);
+        $resolverDefinition->replaceArgument(3, $config['cache_prefix']);
+        $resolverDefinition->addTag('liip_imagine.cache.resolver', array(
+            'resolver' => $resolverName
+        ));
+        $resolverId = 'liip_imagine.cache.resolver.'.$resolverName;
+
+        $container->setDefinition($resolverId, $resolverDefinition);
+
+        return $resolverId;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getName()
+    {
+        return 'web_path';
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function addConfiguration(ArrayNodeDefinition $builder)
+    {
+        $builder
+            ->addDefaultsIfNotSet()
+            ->children()
+                ->scalarNode('web_root')->defaultValue('%kernel.root_dir%/../web')->cannotBeEmpty()->end()
+                ->scalarNode('cache_prefix')->defaultValue('media/cache')->cannotBeEmpty()->end()
+            ->end()
+        ;
+    }
+}
diff --git a/DependencyInjection/LiipImagineExtension.php b/DependencyInjection/LiipImagineExtension.php
index f46d3ea2f..bb0acd556 100644
--- a/DependencyInjection/LiipImagineExtension.php
+++ b/DependencyInjection/LiipImagineExtension.php
@@ -2,32 +2,62 @@
 
 namespace Liip\ImagineBundle\DependencyInjection;
 
+use Liip\ImagineBundle\DependencyInjection\Factory\Loader\LoaderFactoryInterface;
+use Liip\ImagineBundle\DependencyInjection\Factory\Resolver\ResolverFactoryInterface;
 use Symfony\Component\Config\FileLocator;
-
 use Symfony\Component\DependencyInjection\Alias;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;
-
 use Symfony\Component\HttpKernel\DependencyInjection\Extension;
-use Symfony\Component\HttpKernel\Kernel;
 
 class LiipImagineExtension extends Extension
 {
+    /**
+     * @var ResolverFactoryInterface[]
+     */
+    protected $resolversFactories = array();
+
+    /**
+     * @var LoaderFactoryInterface[]
+     */
+    protected $loadersFactories = array();
+
+    /**
+     * @param ResolverFactoryInterface $resolverFactory
+     */
+    public function addResolverFactory(ResolverFactoryInterface $resolverFactory)
+    {
+        $this->resolversFactories[$resolverFactory->getName()] = $resolverFactory;
+    }
+
+    /**
+     * @param LoaderFactoryInterface $loaderFactory
+     */
+    public function addLoaderFactory(LoaderFactoryInterface $loaderFactory)
+    {
+        $this->loadersFactories[$loaderFactory->getName()] = $loaderFactory;
+    }
+
     /**
      * @see Symfony\Component\DependencyInjection\Extension.ExtensionInterface::load()
      */
     public function load(array $configs, ContainerBuilder $container)
     {
-        $config = $this->processConfiguration(new Configuration(), $configs);
+        $config = $this->processConfiguration(
+            new Configuration($this->resolversFactories, $this->loadersFactories),
+            $configs
+        );
+
+        $this->loadResolvers($config['resolvers'], $container);
+        $this->loadLoaders($config['loaders'], $container);
 
         $loader = new XmlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
         $loader->load('imagine.xml');
 
         $container->setAlias('liip_imagine', new Alias('liip_imagine.'.$config['driver']));
 
-        $cachePrefix = $config['cache_prefix'] ? '/'.trim($config['cache_prefix'], '/') : '';
-        $container->setParameter('liip_imagine.cache_prefix', $cachePrefix);
-        $container->setParameter('liip_imagine.web_root', $config['web_root']);
+        $container->setParameter('liip_imagine.cache_prefix', 'media/cache');
+        $container->setParameter('liip_imagine.web_root', '%kernel.root_dir%/../web');
         $container->setParameter('liip_imagine.data_root', $config['data_root']);
         $container->setParameter('liip_imagine.formats', $config['formats']);
         $container->setParameter('liip_imagine.cache.resolver.default', $config['cache']);
@@ -49,4 +79,32 @@ public function load(array $configs, ContainerBuilder $container)
         $resources[] = 'LiipImagineBundle:Form:form_div_layout.html.twig';
         $container->setParameter('twig.form.resources', $resources);
     }
+
+    /**
+     * @param array $config
+     * @param ContainerBuilder $container
+     */
+    protected function loadResolvers(array $config, ContainerBuilder $container)
+    {
+        foreach ($config as $resolverName => $resolverConfig) {
+            $factoryName = key($resolverConfig);
+            $factory = $this->resolversFactories[$factoryName];
+
+            $factory->create($container, $resolverName, $resolverConfig[$factoryName]);
+        }
+    }
+
+    /**
+     * @param array $config
+     * @param ContainerBuilder $container
+     */
+    protected function loadLoaders(array $config, ContainerBuilder $container)
+    {
+        foreach ($config as $loaderName => $loaderConfig) {
+            $factoryName = key($loaderConfig);
+            $factory = $this->loadersFactories[$factoryName];
+
+            $factory->create($container, $loaderName, $loaderConfig[$factoryName]);
+        }
+    }
 }
diff --git a/LiipImagineBundle.php b/LiipImagineBundle.php
index 70db038bf..afd0f6036 100644
--- a/LiipImagineBundle.php
+++ b/LiipImagineBundle.php
@@ -3,7 +3,10 @@
 namespace Liip\ImagineBundle;
 
 use Liip\ImagineBundle\DependencyInjection\Compiler\LoadersCompilerPass;
-
+use Liip\ImagineBundle\DependencyInjection\Factory\Loader\StreamLoaderFactory;
+use Liip\ImagineBundle\DependencyInjection\Factory\Resolver\AwsS3ResolverFactory;
+use Liip\ImagineBundle\DependencyInjection\Factory\Resolver\WebPathResolverFactory;
+use Liip\ImagineBundle\DependencyInjection\LiipImagineExtension;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\HttpKernel\Bundle\Bundle;
 
@@ -17,5 +20,13 @@ public function build(ContainerBuilder $container)
         parent::build($container);
 
         $container->addCompilerPass(new LoadersCompilerPass());
+
+        /** @var $extension LiipImagineExtension */
+        $extension = $container->getExtension('liip_imagine');
+
+        $extension->addResolverFactory(new WebPathResolverFactory);
+        $extension->addResolverFactory(new AwsS3ResolverFactory);
+
+        $extension->addLoaderFactory(new StreamLoaderFactory);
     }
 }
diff --git a/README.md b/README.md
index 6d2c30a7b..37e87b8c1 100644
--- a/README.md
+++ b/README.md
@@ -54,7 +54,12 @@ you want to thumbnail an image to a size of 120x90 pixels:
 # app/config/config.yml
 
 liip_imagine:
+    resolvers:
+       default:
+          web_path: ~
+
     filter_sets:
+        cache: default
         my_thumb:
             quality: 75
             filters:
diff --git a/Resources/config/imagine.xml b/Resources/config/imagine.xml
index 0b3e3dfb4..807c4b245 100644
--- a/Resources/config/imagine.xml
+++ b/Resources/config/imagine.xml
@@ -54,6 +54,8 @@
 
         <parameter key="liip_imagine.cache.resolver.web_path.class">Liip\ImagineBundle\Imagine\Cache\Resolver\WebPathResolver</parameter>
         <parameter key="liip_imagine.cache.resolver.no_cache_web_path.class">Liip\ImagineBundle\Imagine\Cache\Resolver\NoCacheWebPathResolver</parameter>
+        <parameter key="liip_imagine.cache.resolver.aws_s3.class">Liip\ImagineBundle\Imagine\Cache\Resolver\AwsS3Resolver</parameter>
+        <parameter key="liip_imagine.cache.resolver.cache.class">Liip\ImagineBundle\Imagine\Cache\Resolver\CacheResolver</parameter>
 
         <!-- Form types -->
 
@@ -183,15 +185,30 @@
             <argument>%liip_imagine.data_root%</argument>
         </service>
 
+        <service id="liip_imagine.data.loader.prototype.stream" class="%liip_imagine.data.loader.stream.class%">
+            <argument><!-- will be injected by StreamLoaderFactory --></argument>
+            <argument><!-- will be injected by StreamLoaderFactory --></argument>
+        </service>
+
         <!-- Cache resolver -->
 
-        <service id="liip_imagine.cache.resolver.web_path" class="%liip_imagine.cache.resolver.web_path.class%" public="true">
+        <service id="liip_imagine.cache.resolver.prototype.web_path" class="%liip_imagine.cache.resolver.web_path.class%" public="true" abstract="true">
             <argument type="service" id="filesystem" />
             <argument type="service" id="router.request_context" />
-            <argument>%liip_imagine.web_root%</argument>
-            <argument>%liip_imagine.cache_prefix%</argument>
+            <argument><!-- will be injected by WebPathResolverFactory --></argument>
+            <argument><!-- will be injected by WebPathResolverFactory --></argument>
+        </service>
+
+        <service id="liip_imagine.cache.resolver.prototype.aws_s3" class="%liip_imagine.cache.resolver.aws_s3.class%" public="true" abstract="true">
+            <argument><!-- will be injected by AwsS3ResolverFactory --></argument>
+            <argument><!-- will be injected by AwsS3ResolverFactory --></argument>
+            <argument><!-- will be injected by AwsS3ResolverFactory --></argument>
+            <argument><!-- will be injected by AwsS3ResolverFactory --></argument>
+        </service>
 
-            <tag name="liip_imagine.cache.resolver" resolver="web_path" />
+        <service id="liip_imagine.cache.resolver.prototype.cache" class="%liip_imagine.cache.resolver.cache.class%" public="true" abstract="true">
+            <argument><!-- will be injected by a ResolverFactory --></argument>
+            <argument><!-- will be injected by a ResolverFactory --></argument>
         </service>
 
         <service id="liip_imagine.cache.resolver.no_cache_web_path" class="%liip_imagine.cache.resolver.no_cache_web_path.class%" public="true">
diff --git a/Resources/doc/cache-resolver/aws_s3.md b/Resources/doc/cache-resolver/aws_s3.md
index 249cae39e..0936d78a8 100644
--- a/Resources/doc/cache-resolver/aws_s3.md
+++ b/Resources/doc/cache-resolver/aws_s3.md
@@ -2,24 +2,37 @@
 
 The AwsS3Resolver requires the [aws-sdk-php](https://github.com/aws/aws-sdk-php).
 
-You can add the SDK by adding those lines to your `deps` file.
+You can add the SDK by runnig composer.
 
-``` ini
-[aws-sdk]
-    git=git://github.com/aws/aws-sdk-php.git
+```bash
+composer require "aws/aws-sdk-php:~2"
 ```
 
 Afterwards, you only need to configure some information regarding your AWS account and the bucket.
 
 ``` yaml
 parameters:
-    amazon_s3.key: 'your-aws-key'
-    amazon_s3.secret: 'your-aws-secret'
-    amazon_s3.bucket: 'your-bucket.example.com'
-    amazon_s3.region: 'your-bucket-region'
+    amazon.s3.key:    'your-aws-key'
+    amazon.s3.secret: 'your-aws-secret'
+    amazon.s3.bucket: 'your-bucket.example.com'
+    amazon.s3.region: 'your-bucket-region'
 ```
 
-Now you can set up the services required:
+## Create resolver using factory
+
+liip_imagine:
+    resolvers:
+       profile_photos:
+          aws_s3:
+              client_config:
+                  key:    %amazon.s3.key%
+                  secret: %amazon.s3.secret%
+                  region: %amazon.s3.region%
+              bucket:     %amazon.s3.cache_bucket%
+
+## Create resolver as a service
+
+You have to set up the services required:
 
 ``` yaml
 services:
@@ -29,25 +42,27 @@ services:
         factory_method:  factory
         arguments:
             -
-                key: %amazon_s3.key%
-                secret: %amazon_s3.secret%
-                region: %amazon_s3.region%
+                key: %amazon.s3.key%
+                secret: %amazon.s3.secret%
+                region: %amazon.s3.region%
 
     acme.imagine.cache.resolver.amazon_s3:
         class: Liip\ImagineBundle\Imagine\Cache\Resolver\AwsS3Resolver
         arguments:
             - "@acme.amazon_s3"
-            - "%amazon_s3.bucket%"
+            - "%amazon.s3.bucket%"
         tags:
-            - { name: 'liip_imagine.cache.resolver', resolver: 'amazon_s3' }
+            - { name: 'liip_imagine.cache.resolver', resolver: 'profile_photos' }
 ```
 
+## Usage
+
 Now you are ready to use the `AwsS3Resolver` by configuring the bundle.
 The following example will configure the resolver is default.
 
 ``` yaml
 liip_imagine:
-    cache: 'amazon_s3'
+    cache: profile_photos
 ```
 
 If you want to use other buckets for other images, simply alter the parameter names and create additional services!
diff --git a/Resources/doc/cache-resolver/web_path.md b/Resources/doc/cache-resolver/web_path.md
new file mode 100644
index 000000000..08d929f8a
--- /dev/null
+++ b/Resources/doc/cache-resolver/web_path.md
@@ -0,0 +1,18 @@
+# WebPathResolver
+
+## Create resolver
+
+liip_imagine:
+    resolvers:
+       profile_photos:
+          web_path: ~
+
+## Use it
+
+``` yaml
+liip_imagine:
+    cache: profile_photos
+```
+
+- [Back to cache resolvers](../cache-resolvers.md)
+- [Back to the index](../index.md)
diff --git a/Resources/doc/cache-resolvers.md b/Resources/doc/cache-resolvers.md
index f6a0441ed..16ea1d4d4 100644
--- a/Resources/doc/cache-resolvers.md
+++ b/Resources/doc/cache-resolvers.md
@@ -1,5 +1,6 @@
 # Built-In CacheResolver
 
+* [Web path](cache-resolver/web_path.md)
 * [AmazonS3](cache-resolver/amazons3.md)
 * [AwsS3](cache-resolver/aws_s3.md) - for SDK version 2
 * [CacheResolver](cache-resolver/cache.md)
diff --git a/Resources/doc/data-loader/stream.md b/Resources/doc/data-loader/stream.md
index e190c4bfc..8283eb327 100644
--- a/Resources/doc/data-loader/stream.md
+++ b/Resources/doc/data-loader/stream.md
@@ -1,5 +1,15 @@
 # StreamLoader
 
+## Using factory
+
+liip_imagine:
+    loaders:
+        stream.profile_photos:
+            stream:
+                wrapper: gaufrette://profile_photos
+
+## Custom
+
 The `Liip\ImagineBundle\Imagine\Data\Loader\StreamLoader` allows to read images from any stream registered
 thus allowing you to serve your images from literally anywhere.
 
@@ -12,14 +22,23 @@ you can make use of the [StreamWrapper configuration](https://github.com/KnpLabs
 
 ``` yaml
 services:
-    liip_imagine.data.loader.stream.profile_photos:
+    acme.liip_imagine.data.loader.stream.profile_photos:
         class: "%liip_imagine.data.loader.stream.class%"
         arguments:
-            - "@liip_imagine"
             - 'gaufrette://profile_photos/'
         tags:
             - { name: 'liip_imagine.data.loader', loader: 'stream.profile_photos' }
 ```
 
+## Usage
+
+Now you are ready to use the `AwsS3Resolver` by configuring the bundle.
+The following example will configure the resolver is default.
+
+``` yaml
+liip_imagine:
+    data_loader: stream.profile_photos
+```
+
 - [Back to data loaders](../data-loaders.md)
 - [Back to the index](../index.md)
diff --git a/Tests/DependencyInjection/ConfigurationTest.php b/Tests/DependencyInjection/ConfigurationTest.php
new file mode 100644
index 000000000..26baf6ab0
--- /dev/null
+++ b/Tests/DependencyInjection/ConfigurationTest.php
@@ -0,0 +1,178 @@
+<?php
+namespace Liip\ImagineBundle\Tests\DependencyInjection;
+
+use Liip\ImagineBundle\DependencyInjection\Configuration;
+use Liip\ImagineBundle\DependencyInjection\Factory\Loader\LoaderFactoryInterface;
+use Liip\ImagineBundle\DependencyInjection\Factory\Resolver\ResolverFactoryInterface;
+use Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition;
+use Symfony\Component\Config\Definition\ConfigurationInterface;
+use Symfony\Component\Config\Definition\Processor;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+class ConfigurationTest extends \Phpunit_Framework_TestCase
+{
+    public function testImplementsConfigurationInterface()
+    {
+        $rc = new \ReflectionClass('Liip\ImagineBundle\DependencyInjection\Configuration');
+
+        $this->assertTrue($rc->implementsInterface('Symfony\Component\Config\Definition\ConfigurationInterface'));
+    }
+
+    public function testCouldBeConstructedWithResolversAndLoadersFactoriesAsArguments()
+    {
+        new Configuration(array(), array());
+    }
+
+    public function testInjectLoaderFactoryConfig()
+    {
+        $config = $this->processConfiguration(
+            new Configuration(array(), array(new FooLoaderFactory)),
+            array(array(
+                'loaders' => array(
+                    'aLoader' => array(
+                        'foo' => array(
+                            'foo_option' => 'theValue'
+                        )
+                    )
+                )
+
+            ))
+        );
+
+        $this->assertArrayHasKey('loaders', $config);
+        $this->assertArrayHasKey('aLoader', $config['loaders']);
+        $this->assertArrayHasKey('foo', $config['loaders']['aLoader']);
+        $this->assertArrayHasKey('foo_option', $config['loaders']['aLoader']['foo']);
+        $this->assertEquals('theValue', $config['loaders']['aLoader']['foo']['foo_option']);
+    }
+
+    public function testAllowToUseLoaderFactorySeveralTimes()
+    {
+        $config = $this->processConfiguration(
+            new Configuration(array(), array(new FooLoaderFactory)),
+            array(array(
+                'loaders' => array(
+                    'aLoader' => array(
+                        'foo' => array(
+                            'foo_option' => 'theValue'
+                        )
+                    ),
+                    'anotherLoader' => array(
+                        'foo' => array(
+                            'foo_option' => 'theValue'
+                        )
+                    )
+                )
+
+            ))
+        );
+
+        $this->assertArrayHasKey('loaders', $config);
+        $this->assertArrayHasKey('aLoader', $config['loaders']);
+        $this->assertArrayHasKey('anotherLoader', $config['loaders']);
+    }
+
+    public function testInjectResolverFactoryConfig()
+    {
+        $config = $this->processConfiguration(
+            new Configuration(array(new BarResolverFactory), array()),
+            array(array(
+                'resolvers' => array(
+                    'aResolver' => array(
+                        'bar' => array(
+                            'bar_option' => 'theValue'
+                        )
+                    )
+                )
+
+            ))
+        );
+
+        $this->assertArrayHasKey('resolvers', $config);
+        $this->assertArrayHasKey('aResolver', $config['resolvers']);
+        $this->assertArrayHasKey('bar', $config['resolvers']['aResolver']);
+        $this->assertArrayHasKey('bar_option', $config['resolvers']['aResolver']['bar']);
+        $this->assertEquals('theValue', $config['resolvers']['aResolver']['bar']['bar_option']);
+    }
+
+    public function testAllowToUseResolverFactorySeveralTimes()
+    {
+        $config = $this->processConfiguration(
+            new Configuration(array(new BarResolverFactory), array()),
+            array(array(
+                'resolvers' => array(
+                    'aResolver' => array(
+                        'bar' => array(
+                            'bar_option' => 'theValue'
+                        )
+                    ),
+                    'anotherResolver' => array(
+                        'bar' => array(
+                            'bar_option' => 'theValue'
+                        )
+                    ),
+                )
+
+            ))
+        );
+
+        $this->assertArrayHasKey('resolvers', $config);
+        $this->assertArrayHasKey('aResolver', $config['resolvers']);
+        $this->assertArrayHasKey('anotherResolver', $config['resolvers']);
+    }
+
+    /**
+     * @param ConfigurationInterface $configuration
+     * @param array $configs
+     *
+     * @return array
+     */
+    protected function processConfiguration(ConfigurationInterface $configuration, array $configs)
+    {
+        $processor = new Processor();
+
+        return $processor->processConfiguration($configuration, $configs);
+    }
+}
+
+class FooLoaderFactory implements LoaderFactoryInterface
+{
+    public function create(ContainerBuilder $container, $loaderName, array $config)
+    {
+    }
+
+    public function getName()
+    {
+        return 'foo';
+    }
+
+    public function addConfiguration(ArrayNodeDefinition $builder)
+    {
+        $builder
+            ->children()
+                ->scalarNode('foo_option')->isRequired()->cannotBeEmpty()->end()
+            ->end()
+        ;
+    }
+}
+
+class BarResolverFactory implements ResolverFactoryInterface
+{
+    public function create(ContainerBuilder $container, $loaderName, array $config)
+    {
+    }
+
+    public function getName()
+    {
+        return 'bar';
+    }
+
+    public function addConfiguration(ArrayNodeDefinition $builder)
+    {
+        $builder
+            ->children()
+                ->scalarNode('bar_option')->isRequired()->cannotBeEmpty()->end()
+            ->end()
+        ;
+    }
+}
\ No newline at end of file
diff --git a/Tests/DependencyInjection/Factory/Loader/StreamLoaderFactoryTest.php b/Tests/DependencyInjection/Factory/Loader/StreamLoaderFactoryTest.php
new file mode 100644
index 000000000..bcebcc7ed
--- /dev/null
+++ b/Tests/DependencyInjection/Factory/Loader/StreamLoaderFactoryTest.php
@@ -0,0 +1,121 @@
+<?php
+namespace Liip\ImagineBundle\Tests\DependencyInjection\Factory\Loader;
+
+use Liip\ImagineBundle\DependencyInjection\Factory\Loader\StreamLoaderFactory;
+use Symfony\Component\Config\Definition\Builder\TreeBuilder;
+use Symfony\Component\Config\Definition\Processor;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+class StreamLoaderFactoryTest extends \Phpunit_Framework_TestCase
+{
+    public function testImplementsLoaderFactoryInterface()
+    {
+        $rc = new \ReflectionClass('Liip\ImagineBundle\DependencyInjection\Factory\Loader\StreamLoaderFactory');
+
+        $this->assertTrue($rc->implementsInterface('Liip\ImagineBundle\DependencyInjection\Factory\Loader\LoaderFactoryInterface'));
+    }
+
+    public function testCouldBeConstructedWithoutAnyArguments()
+    {
+        new StreamLoaderFactory;
+    }
+
+    public function testReturnExpectedName()
+    {
+        $loader = new StreamLoaderFactory;
+
+        $this->assertEquals('stream', $loader->getName());
+    }
+
+    public function testCreateLoaderDefinitionOnCreate()
+    {
+        $container = new ContainerBuilder;
+
+        $loader = new StreamLoaderFactory;
+
+        $loader->create($container, 'theLoaderName', array(
+            'wrapper' => 'theWrapper',
+            'context' => 'theContext',
+        ));
+
+        $this->assertTrue($container->hasDefinition('liip_imagine.data.loader.theloadername'));
+
+        $loaderDefinition = $container->getDefinition('liip_imagine.data.loader.theloadername');
+        $this->assertInstanceOf('Symfony\Component\DependencyInjection\DefinitionDecorator', $loaderDefinition);
+        $this->assertEquals('liip_imagine.data.loader.prototype.stream', $loaderDefinition->getParent());
+
+        $this->assertEquals('theWrapper', $loaderDefinition->getArgument(0));
+        $this->assertEquals('theContext', $loaderDefinition->getArgument(1));
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Config\Definition\Exception\InvalidConfigurationException
+     * @expectedExceptionMessage The child node "wrapper" at path "stream" must be configured.
+     */
+    public function testThrowIfWrapperNotSetOnAddConfiguration()
+    {
+        $treeBuilder = new TreeBuilder();
+        $rootNode = $treeBuilder->root('stream', 'array');
+
+        $resolver = new StreamLoaderFactory;
+        $resolver->addConfiguration($rootNode);
+
+        $this->processConfigTree($treeBuilder, array());
+    }
+
+    public function testProcessCorrectlyOptionsOnAddConfiguration()
+    {
+        $expectedWrapper = 'theWrapper';
+        $expectedContext = 'theContext';
+
+        $treeBuilder = new TreeBuilder();
+        $rootNode = $treeBuilder->root('stream', 'array');
+
+        $loader = new StreamLoaderFactory;
+        $loader->addConfiguration($rootNode);
+
+        $config = $this->processConfigTree($treeBuilder, array(
+            'stream' => array(
+                'wrapper' => $expectedWrapper,
+                'context' => $expectedContext,
+            )
+        ));
+
+        $this->assertArrayHasKey('wrapper', $config);
+        $this->assertEquals($expectedWrapper, $config['wrapper']);
+
+        $this->assertArrayHasKey('context', $config);
+        $this->assertEquals($expectedContext, $config['context']);
+    }
+
+    public function testAddDefaultOptionsIfNotSetOnAddConfiguration()
+    {
+        $treeBuilder = new TreeBuilder();
+        $rootNode = $treeBuilder->root('stream', 'array');
+
+        $loader = new StreamLoaderFactory;
+        $loader->addConfiguration($rootNode);
+
+        $config = $this->processConfigTree($treeBuilder, array(
+            'stream' => array(
+                'wrapper' => 'aWrapper',
+            )
+        ));
+
+        $this->assertArrayHasKey('context', $config);
+        $this->assertNull($config['context']);
+    }
+
+    /**
+     * @param TreeBuilder $treeBuilder
+     * @param array $configs
+     *
+     * @return array
+     */
+    protected function processConfigTree(TreeBuilder $treeBuilder, array $configs)
+    {
+        $processor = new Processor();
+
+        return $processor->process($treeBuilder->buildTree(), $configs);
+    }
+}
diff --git a/Tests/DependencyInjection/Factory/Resolver/AwsS3ResolverFactoryTest.php b/Tests/DependencyInjection/Factory/Resolver/AwsS3ResolverFactoryTest.php
new file mode 100644
index 000000000..c488fd257
--- /dev/null
+++ b/Tests/DependencyInjection/Factory/Resolver/AwsS3ResolverFactoryTest.php
@@ -0,0 +1,243 @@
+<?php
+namespace Liip\ImagineBundle\Tests\DependencyInjection\Factory\Resolver;
+
+use Liip\ImagineBundle\DependencyInjection\Factory\Resolver\AwsS3ResolverFactory;
+use Symfony\Component\Config\Definition\Builder\TreeBuilder;
+use Symfony\Component\Config\Definition\Processor;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+class AwsS3ResolverFactoryTest extends \Phpunit_Framework_TestCase
+{
+    public function testImplementsResolverFactoryInterface()
+    {
+        $rc = new \ReflectionClass('Liip\ImagineBundle\DependencyInjection\Factory\Resolver\AwsS3ResolverFactory');
+
+        $this->assertTrue($rc->implementsInterface('Liip\ImagineBundle\DependencyInjection\Factory\Resolver\ResolverFactoryInterface'));
+    }
+
+    public function testCouldBeConstructedWithoutAnyArguments()
+    {
+        new AwsS3ResolverFactory;
+    }
+
+    public function testReturnExpectedName()
+    {
+        $resolver = new AwsS3ResolverFactory;
+
+        $this->assertEquals('aws_s3', $resolver->getName());
+    }
+
+    public function testCreateResolverDefinitionOnCreate()
+    {
+        $container = new ContainerBuilder;
+
+        $resolver = new AwsS3ResolverFactory;
+
+        $resolver->create($container, 'theResolverName', array(
+            'client_config' => array(),
+            'bucket' => 'theBucket',
+            'acl' => 'theAcl',
+            'url_options' => array('fooKey' => 'fooVal'),
+            'cache' => false
+        ));
+
+        $this->assertTrue($container->hasDefinition('liip_imagine.cache.resolver.theresolvername'));
+
+        $resolverDefinition = $container->getDefinition('liip_imagine.cache.resolver.theresolvername');
+        $this->assertInstanceOf('Symfony\Component\DependencyInjection\DefinitionDecorator', $resolverDefinition);
+        $this->assertEquals('liip_imagine.cache.resolver.prototype.aws_s3', $resolverDefinition->getParent());
+
+        $this->assertInstanceOf('Symfony\Component\DependencyInjection\Reference', $resolverDefinition->getArgument(0));
+        $this->assertEquals('liip_imagine.cache.resolver.theresolvername.client', $resolverDefinition->getArgument(0));
+
+        $this->assertEquals('theBucket', $resolverDefinition->getArgument(1));
+        $this->assertEquals('theAcl', $resolverDefinition->getArgument(2));
+        $this->assertEquals(array('fooKey' => 'fooVal'), $resolverDefinition->getArgument(3));
+    }
+
+    public function testCreateS3ClientDefinitionOnCreate()
+    {
+        $container = new ContainerBuilder;
+
+        $resolver = new AwsS3ResolverFactory;
+
+        $resolver->create($container, 'theResolverName', array(
+            'client_config' => array('theClientConfigKey' => 'theClientConfigVal'),
+            'bucket' => 'aBucket',
+            'acl' => 'aAcl',
+            'url_options' => array(),
+            'cache' => false
+        ));
+
+        $this->assertTrue($container->hasDefinition('liip_imagine.cache.resolver.theresolvername.client'));
+
+        $clientDefinition = $container->getDefinition('liip_imagine.cache.resolver.theresolvername.client');
+        $this->assertEquals('Aws\S3\S3Client', $clientDefinition->getClass());
+        $this->assertEquals('Aws\S3\S3Client', $clientDefinition->getFactoryClass());
+        $this->assertEquals('factory', $clientDefinition->getFactoryMethod());
+        $this->assertEquals(array('theClientConfigKey' => 'theClientConfigVal'), $clientDefinition->getArgument(0));
+    }
+
+    public function testWrapResolverWithCacheOnCreate()
+    {
+        $container = new ContainerBuilder;
+
+        $resolver = new AwsS3ResolverFactory;
+
+        $resolver->create($container, 'theResolverName', array(
+            'client_config' => array(),
+            'bucket' => 'aBucket',
+            'acl' => 'aAcl',
+            'url_options' => array(),
+            'cache' => 'theCacheServiceId',
+        ));
+
+        $this->assertTrue($container->hasDefinition('liip_imagine.cache.resolver.theresolvername.internal'));
+        $internalResolverDefinition = $container->getDefinition('liip_imagine.cache.resolver.theresolvername.internal');
+        $this->assertInstanceOf('Symfony\Component\DependencyInjection\DefinitionDecorator', $internalResolverDefinition);
+        $this->assertEquals('liip_imagine.cache.resolver.prototype.aws_s3', $internalResolverDefinition->getParent());
+
+        $this->assertTrue($container->hasDefinition('liip_imagine.cache.resolver.theresolvername'));
+        $resolverDefinition = $container->getDefinition('liip_imagine.cache.resolver.theresolvername');
+        $this->assertInstanceOf('Symfony\Component\DependencyInjection\DefinitionDecorator', $resolverDefinition);
+        $this->assertEquals('liip_imagine.cache.resolver.prototype.cache', $resolverDefinition->getParent());
+
+        $this->assertInstanceOf('Symfony\Component\DependencyInjection\Reference', $resolverDefinition->getArgument(0));
+        $this->assertEquals('thecacheserviceid', $resolverDefinition->getArgument(0));
+
+        $this->assertInstanceOf('Symfony\Component\DependencyInjection\Reference', $resolverDefinition->getArgument(1));
+        $this->assertEquals('liip_imagine.cache.resolver.theresolvername.internal', $resolverDefinition->getArgument(1));
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Config\Definition\Exception\InvalidConfigurationException
+     * @expectedExceptionMessage The child node "bucket" at path "aws_s3" must be configured.
+     */
+    public function testThrowBucketNotSetOnAddConfiguration()
+    {
+        $treeBuilder = new TreeBuilder();
+        $rootNode = $treeBuilder->root('aws_s3', 'array');
+
+        $resolver = new AwsS3ResolverFactory;
+        $resolver->addConfiguration($rootNode);
+
+        $this->processConfigTree($treeBuilder, array());
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Config\Definition\Exception\InvalidConfigurationException
+     * @expectedExceptionMessage The child node "client_config" at path "aws_s3" must be configured.
+     */
+    public function testThrowClientConfinNotSetOnAddConfiguration()
+    {
+        $treeBuilder = new TreeBuilder();
+        $rootNode = $treeBuilder->root('aws_s3', 'array');
+
+        $resolver = new AwsS3ResolverFactory;
+        $resolver->addConfiguration($rootNode);
+
+        $this->processConfigTree($treeBuilder, array(
+            'aws_s3' => array(
+                'bucket' => 'aBucket',
+            )
+        ));
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Config\Definition\Exception\InvalidConfigurationException
+     * @expectedExceptionMessage Invalid type for path "aws_s3.client_config". Expected array, but got string
+     */
+    public function testThrowClientConfinNotArrayOnAddConfiguration()
+    {
+        $treeBuilder = new TreeBuilder();
+        $rootNode = $treeBuilder->root('aws_s3', 'array');
+
+        $resolver = new AwsS3ResolverFactory;
+        $resolver->addConfiguration($rootNode);
+
+        $this->processConfigTree($treeBuilder, array(
+            'aws_s3' => array(
+                'bucket' => 'aBucket',
+                'client_config' => 'not_array',
+            )
+        ));
+    }
+
+    public function testProcessCorrectlyOptionsOnAddConfiguration()
+    {
+        $expectedClientConfig = array(
+            'theKey' => 'theClientConfigVal',
+            'theOtherKey' => 'theOtherClientConfigValue'
+        );
+        $expectedUrlOptions = array(
+            'theKey' => 'theUrlOptionsVal',
+            'theOtherKey' => 'theOtherUrlOptionsValue'
+        );
+        $expectedBucket = 'theBucket';
+        $expectedAcl = 'theAcl';
+
+        $treeBuilder = new TreeBuilder();
+        $rootNode = $treeBuilder->root('aws_s3', 'array');
+
+        $resolver = new AwsS3ResolverFactory;
+        $resolver->addConfiguration($rootNode);
+
+        $config = $this->processConfigTree($treeBuilder, array(
+            'aws_s3' => array(
+                'bucket' => $expectedBucket,
+                'acl' => $expectedAcl,
+                'client_config' => $expectedClientConfig,
+                'url_options' => $expectedUrlOptions
+            )
+        ));
+
+        $this->assertArrayHasKey('bucket', $config);
+        $this->assertEquals($expectedBucket, $config['bucket']);
+
+        $this->assertArrayHasKey('acl', $config);
+        $this->assertEquals($expectedAcl, $config['acl']);
+
+        $this->assertArrayHasKey('client_config', $config);
+        $this->assertEquals($expectedClientConfig, $config['client_config']);
+
+        $this->assertArrayHasKey('url_options', $config);
+        $this->assertEquals($expectedUrlOptions, $config['url_options']);
+    }
+
+    public function testAddDefaultOptionsIfNotSetOnAddConfiguration()
+    {
+        $expectedAcl = 'public-read';
+
+        $treeBuilder = new TreeBuilder();
+        $rootNode = $treeBuilder->root('aws_s3', 'array');
+
+        $resolver = new AwsS3ResolverFactory;
+        $resolver->addConfiguration($rootNode);
+
+        $config = $this->processConfigTree($treeBuilder, array(
+            'aws_s3' => array(
+                'bucket' => 'aBucket',
+                'client_config' => array(),
+            )
+        ));
+
+        $this->assertArrayHasKey('acl', $config);
+        $this->assertEquals($expectedAcl, $config['acl']);
+
+        $this->assertArrayHasKey('url_options', $config);
+        $this->assertEquals(array(), $config['url_options']);
+    }
+
+    /**
+     * @param TreeBuilder $treeBuilder
+     * @param array $configs
+     *
+     * @return array
+     */
+    protected function processConfigTree(TreeBuilder $treeBuilder, array $configs)
+    {
+        $processor = new Processor();
+
+        return $processor->process($treeBuilder->buildTree(), $configs);
+    }
+}
diff --git a/Tests/DependencyInjection/Factory/Resolver/WebPathResolverFactoryTest.php b/Tests/DependencyInjection/Factory/Resolver/WebPathResolverFactoryTest.php
new file mode 100644
index 000000000..7ca8f2197
--- /dev/null
+++ b/Tests/DependencyInjection/Factory/Resolver/WebPathResolverFactoryTest.php
@@ -0,0 +1,107 @@
+<?php
+namespace Liip\ImagineBundle\Tests\DependencyInjection\Factory\Resolver;
+
+use Liip\ImagineBundle\DependencyInjection\Factory\Resolver\WebPathResolverFactory;
+use Symfony\Component\Config\Definition\Builder\TreeBuilder;
+use Symfony\Component\Config\Definition\Processor;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+class WebPathResolverFactoryTest extends \Phpunit_Framework_TestCase
+{
+    public function testImplementsResolverFactoryInterface()
+    {
+        $rc = new \ReflectionClass('Liip\ImagineBundle\DependencyInjection\Factory\Resolver\WebPathResolverFactory');
+
+        $this->assertTrue($rc->implementsInterface('Liip\ImagineBundle\DependencyInjection\Factory\Resolver\ResolverFactoryInterface'));
+    }
+
+    public function testCouldBeConstructedWithoutAnyArguments()
+    {
+        new WebPathResolverFactory;
+    }
+
+    public function testReturnExpectedName()
+    {
+        $resolver = new WebPathResolverFactory;
+
+        $this->assertEquals('web_path', $resolver->getName());
+    }
+
+    public function testCreateResolverDefinitionOnCreate()
+    {
+        $container = new ContainerBuilder;
+
+        $resolver = new WebPathResolverFactory;
+
+        $resolver->create($container, 'theResolverName', array(
+            'web_root' => 'theWebRoot',
+            'cache_prefix' => 'theCachePrefix',
+        ));
+
+        $this->assertTrue($container->hasDefinition('liip_imagine.cache.resolver.theresolvername'));
+
+        $resolverDefinition = $container->getDefinition('liip_imagine.cache.resolver.theresolvername');
+        $this->assertInstanceOf('Symfony\Component\DependencyInjection\DefinitionDecorator', $resolverDefinition);
+        $this->assertEquals('liip_imagine.cache.resolver.prototype.web_path', $resolverDefinition->getParent());
+
+        $this->assertEquals('theWebRoot', $resolverDefinition->getArgument(2));
+        $this->assertEquals('theCachePrefix', $resolverDefinition->getArgument(3));
+    }
+
+    public function testProcessCorrectlyOptionsOnAddConfiguration()
+    {
+        $expectedWebPath = 'theWebPath';
+        $expectedCachePrefix = 'theCachePrefix';
+
+        $treeBuilder = new TreeBuilder();
+        $rootNode = $treeBuilder->root('web_path', 'array');
+
+        $resolver = new WebPathResolverFactory;
+        $resolver->addConfiguration($rootNode);
+
+        $config = $this->processConfigTree($treeBuilder, array(
+            'web_path' => array(
+                'web_root' => $expectedWebPath,
+                'cache_prefix' => $expectedCachePrefix,
+            )
+        ));
+
+        $this->assertArrayHasKey('web_root', $config);
+        $this->assertEquals($expectedWebPath, $config['web_root']);
+
+        $this->assertArrayHasKey('cache_prefix', $config);
+        $this->assertEquals($expectedCachePrefix, $config['cache_prefix']);
+    }
+
+    public function testAddDefaultOptionsIfNotSetOnAddConfiguration()
+    {
+        $treeBuilder = new TreeBuilder();
+        $rootNode = $treeBuilder->root('web_path', 'array');
+
+        $resolver = new WebPathResolverFactory;
+        $resolver->addConfiguration($rootNode);
+
+        $config = $this->processConfigTree($treeBuilder, array(
+            'web_path' => array()
+        ));
+
+        $this->assertArrayHasKey('web_root', $config);
+        $this->assertEquals('%kernel.root_dir%/../web', $config['web_root']);
+
+        $this->assertArrayHasKey('cache_prefix', $config);
+        $this->assertEquals('media/cache', $config['cache_prefix']);
+    }
+
+    /**
+     * @param TreeBuilder $treeBuilder
+     * @param array $configs
+     *
+     * @return array
+     */
+    protected function processConfigTree(TreeBuilder $treeBuilder, array $configs)
+    {
+        $processor = new Processor();
+
+        return $processor->process($treeBuilder->buildTree(), $configs);
+    }
+}
diff --git a/Tests/DependencyInjection/LiipImagineExtensionTest.php b/Tests/DependencyInjection/LiipImagineExtensionTest.php
index dd935dd5f..dd99894b8 100644
--- a/Tests/DependencyInjection/LiipImagineExtensionTest.php
+++ b/Tests/DependencyInjection/LiipImagineExtensionTest.php
@@ -4,10 +4,8 @@
 
 use Liip\ImagineBundle\Tests\AbstractTest;
 use Liip\ImagineBundle\DependencyInjection\LiipImagineExtension;
-
 use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\DependencyInjection\Reference;
-use Symfony\Component\HttpKernel\Kernel;
 use Symfony\Component\Yaml\Parser;
 
 /**
@@ -35,7 +33,7 @@ public function testLoadWithDefaults()
     {
         $this->createEmptyConfiguration();
 
-        $this->assertParameter('web_path', 'liip_imagine.cache.resolver.default');
+        $this->assertParameter('default', 'liip_imagine.cache.resolver.default');
         $this->assertAlias('liip_imagine.gd', 'liip_imagine');
         $this->assertHasDefinition('liip_imagine.controller');
         $this->assertDICConstructorArguments(
@@ -85,8 +83,6 @@ protected function getFullConfig()
     {
         $yaml = <<<EOF
 driver: imagick
-web_root: ../foo/bar
-cache_prefix: /imagine/cache
 cache: false
 formats: ['json', 'xml', 'jpg', 'png', 'gif']
 filter_sets:
diff --git a/Tests/Functional/Imagine/Cache/Resolver/WebPathResolverTest.php b/Tests/Functional/Imagine/Cache/Resolver/WebPathResolverTest.php
deleted file mode 100644
index 13dd93d3f..000000000
--- a/Tests/Functional/Imagine/Cache/Resolver/WebPathResolverTest.php
+++ /dev/null
@@ -1,21 +0,0 @@
-<?php
-
-namespace Liip\ImagineBundle\Tests\Functional\Imagine\Cache\Resolver;
-
-use Liip\ImagineBundle\Tests\Functional\WebTestCase;
-use Symfony\Component\HttpFoundation\Request;
-
-/**
- * @covers Liip\ImagineBundle\Imagine\Cache\Resolver\WebPathResolver
- */
-class WebPathResolverTest extends WebTestCase
-{
-    public function testCouldBeGetFromContainer()
-    {
-        $this->createClient();
-
-        $resolver = self::$kernel->getContainer()->get('liip_imagine.cache.resolver.web_path');
-
-        $this->assertInstanceOf('Liip\ImagineBundle\Imagine\Cache\Resolver\WebPathResolver', $resolver);
-    }
-}
diff --git a/Tests/Functional/app/web/media/cache/thumbnail_web_path/S8rrlhhQ/images/cats.jpeg b/Tests/Functional/app/web/media/cache/thumbnail_web_path/S8rrlhhQ/images/cats.jpeg
new file mode 100644
index 0000000000000000000000000000000000000000..8986710665c4891376d82266c2b27a9cd0854d81
GIT binary patch
literal 2833
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
bRT`@BOVkDtn_)_rDl=#XeNk^Gl{fuQh&n&p

literal 0
HcmV?d00001

diff --git a/Tests/LiipImagineBundleTest.php b/Tests/LiipImagineBundleTest.php
new file mode 100644
index 000000000..82c2e1b69
--- /dev/null
+++ b/Tests/LiipImagineBundleTest.php
@@ -0,0 +1,122 @@
+<?php
+namespace Liip\ImagineBundle\Tests;
+
+use Liip\ImagineBundle\DependencyInjection\LiipImagineExtension;
+use Liip\ImagineBundle\LiipImagineBundle;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+class LiipImagineBundleTest extends \Phpunit_Framework_TestCase
+{
+    public function testSubClassOfBundle()
+    {
+        $rc = new \ReflectionClass('Liip\ImagineBundle\LiipImagineBundle');
+
+        $this->assertTrue($rc->isSubclassOf('Symfony\Component\HttpKernel\Bundle\Bundle'));
+    }
+
+    public function testCouldBeConstructedWithoutAnyArguments()
+    {
+        new LiipImagineBundle;
+    }
+
+    public function testAddLoadersCompilerPassOnBuild()
+    {
+        $containerMock = $this->createContainerBuilderMock();
+        $containerMock
+            ->expects($this->atLeastOnce())
+            ->method('getExtension')
+            ->with('liip_imagine')
+            ->will($this->returnValue($this->createExtensionMock()))
+        ;
+        $containerMock
+            ->expects($this->once())
+            ->method('addCompilerPass')
+            ->with($this->isInstanceOf('Liip\ImagineBundle\DependencyInjection\Compiler\LoadersCompilerPass'))
+        ;
+
+        $bundle = new LiipImagineBundle;
+
+        $bundle->build($containerMock);
+    }
+
+    public function testAddWebPathResolverFactoryOnBuild()
+    {
+        $extensionMock = $this->createExtensionMock();
+        $extensionMock
+            ->expects($this->at(0))
+            ->method('addResolverFactory')
+            ->with($this->isInstanceOf('Liip\ImagineBundle\DependencyInjection\Factory\Resolver\WebPathResolverFactory'))
+        ;
+
+        $containerMock = $this->createContainerBuilderMock();
+        $containerMock
+            ->expects($this->atLeastOnce())
+            ->method('getExtension')
+            ->with('liip_imagine')
+            ->will($this->returnValue($extensionMock))
+        ;
+
+        $bundle = new LiipImagineBundle;
+
+        $bundle->build($containerMock);
+    }
+
+    public function testAddAwsS3ResolverFactoryOnBuild()
+    {
+        $extensionMock = $this->createExtensionMock();
+        $extensionMock
+            ->expects($this->at(1))
+            ->method('addResolverFactory')
+            ->with($this->isInstanceOf('Liip\ImagineBundle\DependencyInjection\Factory\Resolver\AwsS3ResolverFactory'))
+        ;
+
+        $containerMock = $this->createContainerBuilderMock();
+        $containerMock
+            ->expects($this->atLeastOnce())
+            ->method('getExtension')
+            ->with('liip_imagine')
+            ->will($this->returnValue($extensionMock))
+        ;
+
+        $bundle = new LiipImagineBundle;
+
+        $bundle->build($containerMock);
+    }
+
+    public function testAddStreamLoaderFactoryOnBuild()
+    {
+        $extensionMock = $this->createExtensionMock();
+        $extensionMock
+            ->expects($this->at(2))
+            ->method('addLoaderFactory')
+            ->with($this->isInstanceOf('Liip\ImagineBundle\DependencyInjection\Factory\Loader\StreamLoaderFactory'))
+        ;
+
+        $containerMock = $this->createContainerBuilderMock();
+        $containerMock
+            ->expects($this->atLeastOnce())
+            ->method('getExtension')
+            ->with('liip_imagine')
+            ->will($this->returnValue($extensionMock))
+        ;
+
+        $bundle = new LiipImagineBundle;
+
+        $bundle->build($containerMock);
+    }
+
+    protected function createContainerBuilderMock()
+    {
+        return $this->getMock('Symfony\Component\DependencyInjection\ContainerBuilder', array(), array(), '', false);
+    }
+
+    protected function createExtensionMock()
+    {
+        $methods = array(
+            'getNamespace', 'addResolverFactory', 'addLoaderFactory'
+        );
+
+        return $this->getMock('Liip\ImagineBundle\DependencyInjection\LiipImagineExtension', $methods, array(), '', false);
+    }
+
+} 
\ No newline at end of file