diff --git a/PKG-INFO b/PKG-INFO
index 92b710fc..e5168ba9 100644
--- a/PKG-INFO
+++ b/PKG-INFO
@@ -1,153 +1,153 @@
 Metadata-Version: 2.1
 Name: swh.storage
-Version: 0.0.127
+Version: 0.0.128
 Summary: Software Heritage storage manager
 Home-page: https://forge.softwareheritage.org/diffusion/DSTO/
 Author: Software Heritage developers
 Author-email: swh-devel@inria.fr
 License: UNKNOWN
 Project-URL: Bug Reports, https://forge.softwareheritage.org/maniphest
-Project-URL: Source, https://forge.softwareheritage.org/source/swh-storage
 Project-URL: Funding, https://www.softwareheritage.org/donate
+Project-URL: Source, https://forge.softwareheritage.org/source/swh-storage
 Description: swh-storage
         ===========
         
         Abstraction layer over the archive, allowing to access all stored source code
         artifacts as well as their metadata.
         
         See the
         [documentation](https://docs.softwareheritage.org/devel/swh-storage/index.html)
         for more details.
         
         Tests
         -----
         
         Python tests for this module include tests that cannot be run without a local
         Postgres database. You are not obliged to run those tests though:
         
         - `make test`:      will run all tests
         - `make test-nodb`: will run only tests that do not need a local DB
         - `make test-db`:   will run only tests that do need a local DB
         
         If you do want to run DB-related tests, you should ensure you have access zith
         sufficient privileges to a Postgresql database.
         
         ### Using your system database
         
         You need to ensure that your user is authorized to create and drop DBs, and in
         particular DBs named "softwareheritage-test" and "softwareheritage-dev"
         
         Note: the testdata repository (swh-storage-testdata) is not required any more.
         
         ### Using pifpaf
         
         [pifpaf](https://github.com/jd/pifpaf) is a suite of fixtures and a
         command-line tool that allows to start and stop daemons for a quick throw-away
         usage.
         
         It can be used to run tests that need a Postgres database without any other
         configuration reauired nor the need to have special access to a running
         database:
         
         ```bash
         
         $ pifpaf run postgresql make test-db
         [snip]
         ----------------------------------------------------------------------
         Ran 124 tests in 56.203s
         
         OK
         ```
         
         Note that pifpaf is not yet available as a Debian package, so you may have to
         install it in a venv.
         
         
         Development
         -----------
         
         A test server could locally be running for tests.
         
         ### Sample configuration
         
         In either /etc/softwareheritage/storage/storage.yml,
         ~/.config/swh/storage.yml or ~/.swh/storage.yml:
         
         ```
         storage:
           cls: local
           args:
             db: "dbname=softwareheritage-dev user=<user>"
             objstorage:
               cls: pathslicing
               args:
                 root: /home/storage/swh-storage/
                 slicing: 0:2/2:4/4:6
         ```
         
         which means, this uses:
         
         - a local storage instance whose db connection is to
           softwareheritage-dev local instance
         
         - the objstorage uses a local objstorage instance whose:
         
           - root path is /home/storage/swh-storage
         
           - slicing scheme is 0:2/2:4/4:6. This means that the identifier of
             the content (sha1) which will be stored on disk at first level
             with the first 2 hex characters, the second level with the next 2
             hex characters and the third level with the next 2 hex
             characters. And finally the complete hash file holding the raw
             content. For example: 00062f8bd330715c4f819373653d97b3cd34394c
             will be stored at 00/06/2f/00062f8bd330715c4f819373653d97b3cd34394c
         
         Note that the 'root' path should exist on disk.
         
         
         ### Run server
         
         Command:
         ```
         python3 -m swh.storage.api.server ~/.config/swh/storage.yml
         ```
         
         This runs a local swh-storage api at 5002 port.
         
         
         ### And then what?
         
         In your upper layer (loader-git, loader-svn, etc...), you can define a
         remote storage with this snippet of yaml configuration.
         
         ```
         storage:
           cls: remote
           args:
             url: http://localhost:5002/
         ```
         
         You could directly define a local storage with the following snippet:
         
         ```
         storage:
           cls: local
           args:
             db: service=swh-dev
             objstorage:
               cls: pathslicing
               args:
                 root: /home/storage/swh-storage/
                 slicing: 0:2/2:4/4:6
         ```
         
 Platform: UNKNOWN
 Classifier: Programming Language :: Python :: 3
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Operating System :: OS Independent
 Classifier: Development Status :: 5 - Production/Stable
 Description-Content-Type: text/markdown
-Provides-Extra: testing
 Provides-Extra: schemata
+Provides-Extra: testing
 Provides-Extra: listener
diff --git a/swh.storage.egg-info/PKG-INFO b/swh.storage.egg-info/PKG-INFO
index 92b710fc..e5168ba9 100644
--- a/swh.storage.egg-info/PKG-INFO
+++ b/swh.storage.egg-info/PKG-INFO
@@ -1,153 +1,153 @@
 Metadata-Version: 2.1
 Name: swh.storage
-Version: 0.0.127
+Version: 0.0.128
 Summary: Software Heritage storage manager
 Home-page: https://forge.softwareheritage.org/diffusion/DSTO/
 Author: Software Heritage developers
 Author-email: swh-devel@inria.fr
 License: UNKNOWN
 Project-URL: Bug Reports, https://forge.softwareheritage.org/maniphest
-Project-URL: Source, https://forge.softwareheritage.org/source/swh-storage
 Project-URL: Funding, https://www.softwareheritage.org/donate
+Project-URL: Source, https://forge.softwareheritage.org/source/swh-storage
 Description: swh-storage
         ===========
         
         Abstraction layer over the archive, allowing to access all stored source code
         artifacts as well as their metadata.
         
         See the
         [documentation](https://docs.softwareheritage.org/devel/swh-storage/index.html)
         for more details.
         
         Tests
         -----
         
         Python tests for this module include tests that cannot be run without a local
         Postgres database. You are not obliged to run those tests though:
         
         - `make test`:      will run all tests
         - `make test-nodb`: will run only tests that do not need a local DB
         - `make test-db`:   will run only tests that do need a local DB
         
         If you do want to run DB-related tests, you should ensure you have access zith
         sufficient privileges to a Postgresql database.
         
         ### Using your system database
         
         You need to ensure that your user is authorized to create and drop DBs, and in
         particular DBs named "softwareheritage-test" and "softwareheritage-dev"
         
         Note: the testdata repository (swh-storage-testdata) is not required any more.
         
         ### Using pifpaf
         
         [pifpaf](https://github.com/jd/pifpaf) is a suite of fixtures and a
         command-line tool that allows to start and stop daemons for a quick throw-away
         usage.
         
         It can be used to run tests that need a Postgres database without any other
         configuration reauired nor the need to have special access to a running
         database:
         
         ```bash
         
         $ pifpaf run postgresql make test-db
         [snip]
         ----------------------------------------------------------------------
         Ran 124 tests in 56.203s
         
         OK
         ```
         
         Note that pifpaf is not yet available as a Debian package, so you may have to
         install it in a venv.
         
         
         Development
         -----------
         
         A test server could locally be running for tests.
         
         ### Sample configuration
         
         In either /etc/softwareheritage/storage/storage.yml,
         ~/.config/swh/storage.yml or ~/.swh/storage.yml:
         
         ```
         storage:
           cls: local
           args:
             db: "dbname=softwareheritage-dev user=<user>"
             objstorage:
               cls: pathslicing
               args:
                 root: /home/storage/swh-storage/
                 slicing: 0:2/2:4/4:6
         ```
         
         which means, this uses:
         
         - a local storage instance whose db connection is to
           softwareheritage-dev local instance
         
         - the objstorage uses a local objstorage instance whose:
         
           - root path is /home/storage/swh-storage
         
           - slicing scheme is 0:2/2:4/4:6. This means that the identifier of
             the content (sha1) which will be stored on disk at first level
             with the first 2 hex characters, the second level with the next 2
             hex characters and the third level with the next 2 hex
             characters. And finally the complete hash file holding the raw
             content. For example: 00062f8bd330715c4f819373653d97b3cd34394c
             will be stored at 00/06/2f/00062f8bd330715c4f819373653d97b3cd34394c
         
         Note that the 'root' path should exist on disk.
         
         
         ### Run server
         
         Command:
         ```
         python3 -m swh.storage.api.server ~/.config/swh/storage.yml
         ```
         
         This runs a local swh-storage api at 5002 port.
         
         
         ### And then what?
         
         In your upper layer (loader-git, loader-svn, etc...), you can define a
         remote storage with this snippet of yaml configuration.
         
         ```
         storage:
           cls: remote
           args:
             url: http://localhost:5002/
         ```
         
         You could directly define a local storage with the following snippet:
         
         ```
         storage:
           cls: local
           args:
             db: service=swh-dev
             objstorage:
               cls: pathslicing
               args:
                 root: /home/storage/swh-storage/
                 slicing: 0:2/2:4/4:6
         ```
         
 Platform: UNKNOWN
 Classifier: Programming Language :: Python :: 3
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Operating System :: OS Independent
 Classifier: Development Status :: 5 - Production/Stable
 Description-Content-Type: text/markdown
-Provides-Extra: testing
 Provides-Extra: schemata
+Provides-Extra: testing
 Provides-Extra: listener
diff --git a/swh/storage/api/server.py b/swh/storage/api/server.py
index 48996b12..a302ec2d 100644
--- a/swh/storage/api/server.py
+++ b/swh/storage/api/server.py
@@ -1,434 +1,434 @@
 # Copyright (C) 2015-2019  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import os
 import json
 import logging
 
 from flask import request
 
 from swh.core import config
 from swh.storage import get_storage as get_swhstorage
 from swh.core.api import (SWHServerAPIApp, decode_request,
                           error_handler,
                           encode_data_server as encode_data)
 
 app = SWHServerAPIApp(__name__)
 storage = None
 
 
 @app.errorhandler(Exception)
 def my_error_handler(exception):
     return error_handler(exception, encode_data)
 
 
 def get_storage():
     global storage
     if not storage:
         storage = get_swhstorage(**app.config['storage'])
 
     return storage
 
 
 @app.route('/')
 def index():
     return '''<html>
 <head><title>Software Heritage storage server</title></head>
 <body>
 <p>You have reached the
 <a href="https://www.softwareheritage.org/">Software Heritage</a>
 storage server.<br />
 See its
 <a href="https://docs.softwareheritage.org/devel/swh-storage/">documentation
 and API</a> for more information</p>
 </html>'''
 
 
 @app.route('/check_config', methods=['POST'])
 def check_config():
     return encode_data(get_storage().check_config(**decode_request(request)))
 
 
 @app.route('/content/missing', methods=['POST'])
 def content_missing():
     return encode_data(get_storage().content_missing(
         **decode_request(request)))
 
 
 @app.route('/content/missing/sha1', methods=['POST'])
 def content_missing_per_sha1():
     return encode_data(get_storage().content_missing_per_sha1(
         **decode_request(request)))
 
 
 @app.route('/content/present', methods=['POST'])
 def content_find():
     return encode_data(get_storage().content_find(**decode_request(request)))
 
 
 @app.route('/content/add', methods=['POST'])
 def content_add():
     return encode_data(get_storage().content_add(**decode_request(request)))
 
 
 @app.route('/content/update', methods=['POST'])
 def content_update():
     return encode_data(get_storage().content_update(**decode_request(request)))
 
 
 @app.route('/content/data', methods=['POST'])
 def content_get():
     return encode_data(get_storage().content_get(**decode_request(request)))
 
 
 @app.route('/content/metadata', methods=['POST'])
 def content_get_metadata():
     return encode_data(get_storage().content_get_metadata(
         **decode_request(request)))
 
 
 @app.route('/content/range', methods=['POST'])
 def content_get_range():
     return encode_data(get_storage().content_get_range(
         **decode_request(request)))
 
 
 @app.route('/directory/missing', methods=['POST'])
 def directory_missing():
     return encode_data(get_storage().directory_missing(
         **decode_request(request)))
 
 
 @app.route('/directory/add', methods=['POST'])
 def directory_add():
     return encode_data(get_storage().directory_add(**decode_request(request)))
 
 
 @app.route('/directory/path', methods=['POST'])
 def directory_entry_get_by_path():
     return encode_data(get_storage().directory_entry_get_by_path(
         **decode_request(request)))
 
 
 @app.route('/directory/ls', methods=['GET'])
 def directory_ls():
     dir = request.args['directory'].encode('utf-8', 'surrogateescape')
     rec = json.loads(request.args.get('recursive', 'False').lower())
     return encode_data(get_storage().directory_ls(dir, recursive=rec))
 
 
 @app.route('/revision/add', methods=['POST'])
 def revision_add():
     return encode_data(get_storage().revision_add(**decode_request(request)))
 
 
 @app.route('/revision', methods=['POST'])
 def revision_get():
     return encode_data(get_storage().revision_get(**decode_request(request)))
 
 
 @app.route('/revision/log', methods=['POST'])
 def revision_log():
     return encode_data(get_storage().revision_log(**decode_request(request)))
 
 
 @app.route('/revision/shortlog', methods=['POST'])
 def revision_shortlog():
     return encode_data(get_storage().revision_shortlog(
         **decode_request(request)))
 
 
 @app.route('/revision/missing', methods=['POST'])
 def revision_missing():
     return encode_data(get_storage().revision_missing(
         **decode_request(request)))
 
 
 @app.route('/release/add', methods=['POST'])
 def release_add():
     return encode_data(get_storage().release_add(**decode_request(request)))
 
 
 @app.route('/release', methods=['POST'])
 def release_get():
     return encode_data(get_storage().release_get(**decode_request(request)))
 
 
 @app.route('/release/missing', methods=['POST'])
 def release_missing():
     return encode_data(get_storage().release_missing(
         **decode_request(request)))
 
 
 @app.route('/object/find_by_sha1_git', methods=['POST'])
 def object_find_by_sha1_git():
     return encode_data(get_storage().object_find_by_sha1_git(
         **decode_request(request)))
 
 
 @app.route('/snapshot/add', methods=['POST'])
 def snapshot_add():
     return encode_data(get_storage().snapshot_add(**decode_request(request)))
 
 
 @app.route('/snapshot', methods=['POST'])
 def snapshot_get():
     return encode_data(get_storage().snapshot_get(**decode_request(request)))
 
 
 @app.route('/snapshot/by_origin_visit', methods=['POST'])
 def snapshot_get_by_origin_visit():
     return encode_data(get_storage().snapshot_get_by_origin_visit(
         **decode_request(request)))
 
 
 @app.route('/snapshot/latest', methods=['POST'])
 def snapshot_get_latest():
     return encode_data(get_storage().snapshot_get_latest(
         **decode_request(request)))
 
 
 @app.route('/snapshot/count_branches', methods=['POST'])
 def snapshot_count_branches():
     return encode_data(get_storage().snapshot_count_branches(
         **decode_request(request)))
 
 
 @app.route('/snapshot/get_branches', methods=['POST'])
 def snapshot_get_branches():
     return encode_data(get_storage().snapshot_get_branches(
         **decode_request(request)))
 
 
 @app.route('/origin/get', methods=['POST'])
 def origin_get():
     return encode_data(get_storage().origin_get(**decode_request(request)))
 
 
 @app.route('/origin/get_range', methods=['POST'])
 def origin_get_range():
     return encode_data(get_storage().origin_get_range(
         **decode_request(request)))
 
 
 @app.route('/origin/search', methods=['POST'])
 def origin_search():
     return encode_data(get_storage().origin_search(**decode_request(request)))
 
 
 @app.route('/origin/count', methods=['POST'])
 def origin_count():
     return encode_data(get_storage().origin_count(**decode_request(request)))
 
 
 @app.route('/origin/add_multi', methods=['POST'])
 def origin_add():
     return encode_data(get_storage().origin_add(**decode_request(request)))
 
 
 @app.route('/origin/add', methods=['POST'])
 def origin_add_one():
     return encode_data(get_storage().origin_add_one(**decode_request(request)))
 
 
 @app.route('/origin/visit/get', methods=['POST'])
 def origin_visit_get():
     return encode_data(get_storage().origin_visit_get(
         **decode_request(request)))
 
 
 @app.route('/origin/visit/getby', methods=['POST'])
 def origin_visit_get_by():
     return encode_data(
         get_storage().origin_visit_get_by(**decode_request(request)))
 
 
 @app.route('/origin/visit/add', methods=['POST'])
 def origin_visit_add():
     return encode_data(get_storage().origin_visit_add(
         **decode_request(request)))
 
 
 @app.route('/origin/visit/update', methods=['POST'])
 def origin_visit_update():
     return encode_data(get_storage().origin_visit_update(
         **decode_request(request)))
 
 
 @app.route('/person', methods=['POST'])
 def person_get():
     return encode_data(get_storage().person_get(**decode_request(request)))
 
 
 @app.route('/fetch_history', methods=['GET'])
 def fetch_history_get():
     return encode_data(get_storage().fetch_history_get(request.args['id']))
 
 
 @app.route('/fetch_history/start', methods=['POST'])
 def fetch_history_start():
     return encode_data(
         get_storage().fetch_history_start(**decode_request(request)))
 
 
 @app.route('/fetch_history/end', methods=['POST'])
 def fetch_history_end():
     return encode_data(
         get_storage().fetch_history_end(**decode_request(request)))
 
 
 @app.route('/entity/add', methods=['POST'])
 def entity_add():
     return encode_data(
         get_storage().entity_add(**decode_request(request)))
 
 
 @app.route('/entity/get', methods=['POST'])
 def entity_get():
     return encode_data(
         get_storage().entity_get(**decode_request(request)))
 
 
 @app.route('/entity', methods=['GET'])
 def entity_get_one():
     return encode_data(get_storage().entity_get_one(request.args['uuid']))
 
 
 @app.route('/entity/from_lister_metadata', methods=['POST'])
 def entity_from_lister_metadata():
     return encode_data(get_storage().entity_get_from_lister_metadata(
         **decode_request(request)))
 
 
 @app.route('/tool/data', methods=['POST'])
 def tool_get():
     return encode_data(get_storage().tool_get(
         **decode_request(request)))
 
 
 @app.route('/tool/add', methods=['POST'])
 def tool_add():
     return encode_data(get_storage().tool_add(
         **decode_request(request)))
 
 
 @app.route('/origin/metadata/add', methods=['POST'])
 def origin_metadata_add():
     return encode_data(get_storage().origin_metadata_add(**decode_request(
                                                        request)))
 
 
 @app.route('/origin/metadata/get', methods=['POST'])
 def origin_metadata_get_by():
     return encode_data(get_storage().origin_metadata_get_by(**decode_request(
                                                        request)))
 
 
 @app.route('/provider/add', methods=['POST'])
 def metadata_provider_add():
     return encode_data(get_storage().metadata_provider_add(**decode_request(
                                                        request)))
 
 
 @app.route('/provider/get', methods=['POST'])
 def metadata_provider_get():
     return encode_data(get_storage().metadata_provider_get(**decode_request(
                                                        request)))
 
 
 @app.route('/provider/getby', methods=['POST'])
 def metadata_provider_get_by():
     return encode_data(get_storage().metadata_provider_get_by(**decode_request(
                                                        request)))
 
 
 @app.route('/stat/counters', methods=['GET'])
 def stat_counters():
     return encode_data(get_storage().stat_counters())
 
 
 @app.route('/algos/diff_directories', methods=['POST'])
 def diff_directories():
     return encode_data(get_storage().diff_directories(
         **decode_request(request)))
 
 
 @app.route('/algos/diff_revisions', methods=['POST'])
 def diff_revisions():
     return encode_data(get_storage().diff_revisions(**decode_request(request)))
 
 
 @app.route('/algos/diff_revision', methods=['POST'])
 def diff_revision():
     return encode_data(get_storage().diff_revision(**decode_request(request)))
 
 
 api_cfg = None
 
 
 def load_and_check_config(config_file, type='local'):
     """Check the minimal configuration is set to run the api or raise an
        error explanation.
 
     Args:
         config_file (str): Path to the configuration file to load
         type (str): configuration type. For 'local' type, more
                     checks are done.
 
     Raises:
         Error if the setup is not as expected
 
     Returns:
         configuration as a dict
 
     """
     if not config_file:
         raise EnvironmentError('Configuration file must be defined')
 
     if not os.path.exists(config_file):
         raise FileNotFoundError('Configuration file %s does not exist' % (
             config_file, ))
 
     cfg = config.read(config_file)
     if 'storage' not in cfg:
         raise KeyError("Missing '%storage' configuration")
 
     if type == 'local':
         vcfg = cfg['storage']
         cls = vcfg.get('cls')
         if cls != 'local':
-            raise EnvironmentError(
+            raise ValueError(
                 "The storage backend can only be started with a 'local' "
                 "configuration")
 
         args = vcfg['args']
         for key in ('db', 'objstorage'):
             if not args.get(key):
                 raise ValueError(
                     "Invalid configuration; missing '%s' config entry" % key)
 
     return cfg
 
 
 def make_app_from_configfile():
     """Run the WSGI app from the webserver, loading the configuration from
        a configuration file.
 
        SWH_CONFIG_FILENAME environment variable defines the
        configuration path to load.
 
     """
     global api_cfg
     if not api_cfg:
         config_file = os.environ.get('SWH_CONFIG_FILENAME')
         api_cfg = load_and_check_config(config_file)
         app.config.update(api_cfg)
     handler = logging.StreamHandler()
     app.logger.addHandler(handler)
     return app
 
 
 if __name__ == '__main__':
     print('Deprecated. Use swh-storage')
diff --git a/swh/storage/cli.py b/swh/storage/cli.py
index 4c9e1aeb..42bbf9ff 100644
--- a/swh/storage/cli.py
+++ b/swh/storage/cli.py
@@ -1,25 +1,25 @@
 # Copyright (C) 2015-2019  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import click
 
 from swh.storage.api.server import load_and_check_config, app
 
 
 @click.command()
 @click.argument('config-path', required=1)
 @click.option('--host', default='0.0.0.0', help="Host to run the server")
 @click.option('--port', default=5002, type=click.INT,
               help="Binding port of the server")
 @click.option('--debug/--nodebug', default=True,
               help="Indicates if the server should run in debug mode")
-def launch(config_path, host, port, debug):
+def main(config_path, host, port, debug):
     api_cfg = load_and_check_config(config_path, type='any')
     app.config.update(api_cfg)
     app.run(host, port=int(port), debug=bool(debug))
 
 
 if __name__ == '__main__':
-    launch()
+    main()
diff --git a/swh/storage/tests/test_server.py b/swh/storage/tests/test_server.py
index 989275ca..70898b80 100644
--- a/swh/storage/tests/test_server.py
+++ b/swh/storage/tests/test_server.py
@@ -1,129 +1,129 @@
 # Copyright (C) 2019  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import copy
 import pytest
 import yaml
 
 from swh.storage.api.server import load_and_check_config
 
 
 def prepare_config_file(tmpdir, content, name='config.yml'):
     """Prepare configuration file in `$tmpdir/name` with content `content`.
 
     Args:
         tmpdir (LocalPath): root directory
         content (str/dict): Content of the file either as string or as a dict.
                             If a dict, converts the dict into a yaml string.
         name (str): configuration filename
 
     Returns
         path (str) of the configuration file prepared.
 
     """
     config_path = tmpdir / name
     if isinstance(content, dict):  # convert if needed
         content = yaml.dump(content)
     config_path.write_text(content, encoding='utf-8')
     # pytest on python3.5 does not support LocalPath manipulation, so
     # convert path to string
     return str(config_path)
 
 
 def test_load_and_check_config_no_configuration():
     """Inexistant configuration files raises"""
     with pytest.raises(EnvironmentError) as e:
         load_and_check_config(None)
 
     assert e.value.args[0] == 'Configuration file must be defined'
 
     config_path = '/some/inexistant/config.yml'
     with pytest.raises(FileNotFoundError) as e:
         load_and_check_config(config_path)
 
     assert e.value.args[0] == 'Configuration file %s does not exist' % (
         config_path, )
 
 
 def test_load_and_check_config_wrong_configuration(tmpdir):
     """Wrong configuration raises"""
     config_path = prepare_config_file(tmpdir, 'something: useless')
     with pytest.raises(KeyError) as e:
         load_and_check_config(config_path)
 
     assert e.value.args[0] == 'Missing \'%storage\' configuration'
 
 
 def test_load_and_check_config_remote_config_local_type_raise(tmpdir):
     """'local' configuration without 'local' storage raises"""
     config = {
         'storage': {
             'cls': 'remote',
             'args': {}
         }
     }
     config_path = prepare_config_file(tmpdir, config)
-    with pytest.raises(EnvironmentError) as e:
+    with pytest.raises(ValueError) as e:
         load_and_check_config(config_path, type='local')
 
     assert (
         e.value.args[0] ==
         "The storage backend can only be started with a 'local' configuration"
     )
 
 
 def test_load_and_check_config_local_incomplete_configuration(tmpdir):
     """Incomplete 'local' configuration should raise"""
     config = {
         'storage': {
             'cls': 'local',
             'args': {
                 'db': 'database',
                 'objstorage': 'object_storage'
             }
         }
     }
 
     for key in ('db', 'objstorage'):
         c = copy.deepcopy(config)
         c['storage']['args'].pop(key)
         config_path = prepare_config_file(tmpdir, c)
         with pytest.raises(ValueError) as e:
             load_and_check_config(config_path)
 
         assert (
             e.value.args[0] ==
             "Invalid configuration; missing '%s' config entry" % key
         )
 
 
 def test_load_and_check_config_local_config_fine(tmpdir):
     """'Remote configuration is fine"""
     config = {
         'storage': {
             'cls': 'local',
             'args': {
                 'db': 'db',
                 'objstorage': 'something',
             }
         }
     }
     config_path = prepare_config_file(tmpdir, config)
     cfg = load_and_check_config(config_path, type='local')
     assert cfg == config
 
 
 def test_load_and_check_config_remote_config_fine(tmpdir):
     """'Remote configuration is fine"""
     config = {
         'storage': {
             'cls': 'remote',
             'args': {}
         }
     }
     config_path = prepare_config_file(tmpdir, config)
     cfg = load_and_check_config(config_path, type='any')
 
     assert cfg == config
diff --git a/version.txt b/version.txt
index e92a08f8..b2004d1f 100644
--- a/version.txt
+++ b/version.txt
@@ -1 +1 @@
-v0.0.127-0-g95b0b42
\ No newline at end of file
+v0.0.128-0-ga1b8387
\ No newline at end of file