Merge remote-tracking branch 'origin/master' into docs/1077/recommend-ubuntu-16.04-for-now

bigchaindb/__init__.py

@@ -5,6 +5,25 @@ import os
 # PORT_NUMBER = reduce(lambda x, y: x * y, map(ord, 'BigchainDB')) % 2**16
 # basically, the port number is 9984
 
+_database_rethinkdb = {
+    'backend': os.environ.get('BIGCHAINDB_DATABASE_BACKEND', 'rethinkdb'),
+    'host': os.environ.get('BIGCHAINDB_DATABASE_HOST', 'localhost'),
+    'port': int(os.environ.get('BIGCHAINDB_DATABASE_PORT', 28015)),
+    'name': os.environ.get('BIGCHAINDB_DATABASE_NAME', 'bigchain'),
+}
+
+_database_mongodb = {
+    'backend': os.environ.get('BIGCHAINDB_DATABASE_BACKEND', 'mongodb'),
+    'host': os.environ.get('BIGCHAINDB_DATABASE_HOST', 'localhost'),
+    'port': int(os.environ.get('BIGCHAINDB_DATABASE_PORT', 27017)),
+    'name': os.environ.get('BIGCHAINDB_DATABASE_NAME', 'bigchain'),
+    'replicaset': os.environ.get('BIGCHAINDB_DATABASE_REPLICASET', 'bigchain-rs'),
+}
+
+_database_map = {
+    'mongodb': _database_mongodb,
+    'rethinkdb': _database_rethinkdb
+}
 
 config = {
     'server': {
@@ -14,13 +33,9 @@ config = {
         'workers': None,  # if none, the value will be cpu_count * 2 + 1
         'threads': None,  # if none, the value will be cpu_count * 2 + 1
     },
-    'database': {
+    'database': _database_map[
-        'backend': os.environ.get('BIGCHAINDB_DATABASE_BACKEND', 'rethinkdb'),
+        os.environ.get('BIGCHAINDB_DATABASE_BACKEND', 'rethinkdb')
-        'host': os.environ.get('BIGCHAINDB_DATABASE_HOST', 'localhost'),
+    ],
-        'port': int(os.environ.get('BIGCHAINDB_DATABASE_PORT', 28015)),
-        'name': os.environ.get('BIGCHAINDB_DATABASE_NAME', 'bigchain'),
-        'replicaset': os.environ.get('BIGCHAINDB_DATABASE_REPLICASET', 'bigchain-rs'),
-    },
     'keypair': {
         'public': None,
         'private': None,

bigchaindb/backend/connection.py

@@ -40,6 +40,12 @@ def connect(backend=None, host=None, port=None, name=None, replicaset=None):
     host = host or bigchaindb.config['database']['host']
     port = port or bigchaindb.config['database']['port']
     dbname = name or bigchaindb.config['database']['name']
+    # Not sure how to handle this here. This setting is only relevant for
+    # mongodb.
+    # I added **kwargs for both RethinkDBConnection and MongoDBConnection
+    # to handle these these additional args. In case of RethinkDBConnection
+    # it just does not do anything with it.
+    replicaset = replicaset or bigchaindb.config['database'].get('replicaset')
 
     try:
         module_name, _, class_name = BACKENDS[backend].rpartition('.')
@@ -51,7 +57,7 @@ def connect(backend=None, host=None, port=None, name=None, replicaset=None):
         raise ConfigurationError('Error loading backend `{}`'.format(backend)) from exc
 
     logger.debug('Connection: {}'.format(Class))
-    return Class(host, port, dbname)
+    return Class(host, port, dbname, replicaset=replicaset)
 
 
 class Connection:

bigchaindb/backend/mongodb/connection.py

@@ -14,7 +14,7 @@ logger = logging.getLogger(__name__)
 class MongoDBConnection(Connection):
 
     def __init__(self, host=None, port=None, dbname=None, max_tries=3,
-                 replicaset=None):
+                 replicaset=None, **kwargs):
         """Create a new Connection instance.
 
         Args:

bigchaindb/backend/rethinkdb/connection.py

@@ -17,7 +17,7 @@ class RethinkDBConnection(Connection):
           more times to run the query or open a connection.
     """
 
-    def __init__(self, host, port, dbname, max_tries=3):
+    def __init__(self, host, port, dbname, max_tries=3, **kwargs):
         """Create a new :class:`~.RethinkDBConnection` instance.
 
         See :meth:`.Connection.__init__` for

bigchaindb/commands/bigchain.py

@@ -86,6 +86,11 @@ def run_configure(args, skip_if_exists=False):
     conf['keypair']['private'], conf['keypair']['public'] = \
         crypto.generate_key_pair()
 
+    # select the correct config defaults based on the backend
+    print('Generating default configuration for backend {}'
+          .format(args.backend))
+    conf['database'] = bigchaindb._database_map[args.backend]
+
     if not args.yes:
         for key in ('bind', ):
             val = conf['server'][key]
@@ -282,9 +287,13 @@ def create_parser():
                                        dest='command')
 
     # parser for writing a config file
-    subparsers.add_parser('configure',
+    config_parser = subparsers.add_parser('configure',
-                          help='Prepare the config file '
+                                          help='Prepare the config file '
-                               'and create the node keypair')
+                                               'and create the node keypair')
+    config_parser.add_argument('backend',
+                               choices=['rethinkdb', 'mongodb'],
+                               help='The backend to use. It can be either '
+                                    'rethinkdb or mongodb.')
 
     # parsers for showing/exporting config values
     subparsers.add_parser('show-config',

docker-compose.yml

@@ -5,7 +5,7 @@ services:
     image: mongo:3.4.1
     ports:
       - "27017"
-    command: mongod --replSet=rs0
+    command: mongod --replSet=bigchain-rs
 
   rdb:
     image: rethinkdb

docs/server/source/dev-and-test/setup-run-node.md

@@ -7,25 +7,27 @@ The BigchainDB core dev team develops BigchainDB on recent Ubuntu and Fedora dis
 
 ## Option A: Using a Local Dev Machine
 
-First, read through the BigchainDB [CONTRIBUTING.md file](https://github.com/bigchaindb/bigchaindb/blob/master/CONTRIBUTING.md). It outlines the steps to setup a machine for developing and testing BigchainDB.
+Read through the BigchainDB [CONTRIBUTING.md file](https://github.com/bigchaindb/bigchaindb/blob/master/CONTRIBUTING.md). It outlines the steps to setup a machine for developing and testing BigchainDB.
 
-Next, create a default BigchainDB config file (in `$HOME/.bigchaindb`):
+### With RethinkDB
+
+Create a default BigchainDB config file (in `$HOME/.bigchaindb`):
 ```text
-bigchaindb -y configure
+$ bigchaindb -y configure rethinkdb
 ```
 
 Note: [The BigchainDB CLI](../server-reference/bigchaindb-cli.html) and the [BigchainDB Configuration Settings](../server-reference/configuration.html) are documented elsewhere. (Click the links.)
 
 Start RethinkDB using:
 ```text
-rethinkdb
+$ rethinkdb
 ```
 
 You can verify that RethinkDB is running by opening the RethinkDB web interface in your web browser. It should be at [http://localhost:8080/](http://localhost:8080/).
 
 To run BigchainDB Server, do:
 ```text
-bigchaindb start
+$ bigchaindb start
 ```
 
 You can [run all the unit tests](running-unit-tests.html) to test your installation.
@@ -33,13 +35,37 @@ You can [run all the unit tests](running-unit-tests.html) to test your installat
 The BigchainDB [CONTRIBUTING.md file](https://github.com/bigchaindb/bigchaindb/blob/master/CONTRIBUTING.md) has more details about how to contribute.
 
 
-## Option B: Using a Dev Machine on Cloud9
+### With MongoDB
 
-Ian Worrall of [Encrypted Labs](http://www.encryptedlabs.com/) wrote a document (PDF) explaining how to set up a BigchainDB (Server) dev machine on Cloud9:
+Create a default BigchainDB config file (in `$HOME/.bigchaindb`):
+```text
+$ bigchaindb -y configure mongodb
+```
 
-[Download that document from GitHub](https://raw.githubusercontent.com/bigchaindb/bigchaindb/master/docs/server/source/_static/cloud9.pdf)
+Note: [The BigchainDB CLI](../server-reference/bigchaindb-cli.html) and the [BigchainDB Configuration Settings](../server-reference/configuration.html) are documented elsewhere. (Click the links.)
 
-## Option C: Using a Local Dev Machine and Docker
+Start MongoDB __3.4+__ using:
+```text
+$ mongod --replSet=bigchain-rs
+```
+
+You can verify that MongoDB is running correctly by checking the output of the
+previous command for the line:
+```text
+waiting for connections on port 27017
+```
+
+To run BigchainDB Server, do:
+```text
+$ bigchaindb start
+```
+
+You can [run all the unit tests](running-unit-tests.html) to test your installation.
+
+The BigchainDB [CONTRIBUTING.md file](https://github.com/bigchaindb/bigchaindb/blob/master/CONTRIBUTING.md) has more details about how to contribute.
+
+
+## Option B: Using a Local Dev Machine and Docker
 
 You need to have recent versions of [Docker Engine](https://docs.docker.com/engine/installation/)
 and (Docker) [Compose](https://docs.docker.com/compose/install/).
@@ -50,6 +76,8 @@ Build the images:
 docker-compose build
 ```
 
+### Docker with RethinkDB
+
 **Note**: If you're upgrading BigchainDB and have previously already built the images, you may need
 to rebuild them after the upgrade to install any new dependencies.
 
@@ -62,7 +90,7 @@ docker-compose up -d rdb
 The RethinkDB web interface should be accessible at <http://localhost:58080/>.
 Depending on which platform, and/or how you are running docker, you may need
 to change `localhost` for the `ip` of the machine that is running docker. As a
-dummy example, if the `ip` of that machine was `0.0.0.0`, you would accees the
+dummy example, if the `ip` of that machine was `0.0.0.0`, you would access the
 web interface at: <http://0.0.0.0:58080/>.
 
 Start a BigchainDB node:
@@ -83,6 +111,40 @@ If you wish to run the tests:
 docker-compose run --rm bdb py.test -v -n auto
 ```
 
+### Docker with MongoDB
+
+Start MongoDB:
+
+```bash
+docker-compose up -d mdb
+```
+
+MongoDB should now be up and running. You can check the port binding for the
+MongoDB driver port using:
+```bash
+$ docker-compose port mdb 27017
+```
+
+Start a BigchainDB node:
+
+```bash
+docker-compose up -d bdb-mdb
+```
+
+You can monitor the logs:
+
+```bash
+docker-compose logs -f bdb-mdb
+```
+
+If you wish to run the tests:
+
+```bash
+docker-compose run --rm bdb-mdb py.test -v --database-backend=mongodb
+```
+
+### Accessing the HTTP API
+
 A quick check to make sure that the BigchainDB server API is operational:
 
 ```bash
@@ -123,3 +185,9 @@ root:
 ```bash
 curl 0.0.0.0:32772
 ```
+
+## Option C: Using a Dev Machine on Cloud9
+
+Ian Worrall of [Encrypted Labs](http://www.encryptedlabs.com/) wrote a document (PDF) explaining how to set up a BigchainDB (Server) dev machine on Cloud9:
+
+[Download that document from GitHub](https://raw.githubusercontent.com/bigchaindb/bigchaindb/master/docs/server/source/_static/cloud9.pdf)

docs/server/source/drivers-clients/example-apps.rst

@@ -1,10 +0,0 @@
-Example Apps
-============
-
-.. warning::
-
-   There are some example BigchainDB apps (i.e. apps which use BigchainDB) in the GitHub repository named `bigchaindb-examples <https://github.com/bigchaindb/bigchaindb-examples>`_. They were created before there was much of an HTTP API, so instead of communicating with a BigchainDB node via the HTTP API, they communicate directly with the node using the BigchainDB Python server API and the RethinkDB Python Driver. That's not how a real production app would work. The HTTP API is getting better, and we recommend using it to communicate with BigchainDB nodes.
-
-   Moreover, because of changes to the BigchainDB Server code, some of the examples in the bigchaindb-examples repo might not work anymore, or they might not work as expected.
-
-   In the future, we hope to create a set of examples using the HTTP API (or wrappers of it, such as the Python Driver API).

docs/server/source/drivers-clients/index.rst

@@ -14,4 +14,3 @@ your choice, and then use the HTTP API directly to post transactions.
    http-client-server-api
    The Python Driver <https://docs.bigchaindb.com/projects/py-driver/en/latest/index.html>
    Transaction CLI <https://docs.bigchaindb.com/projects/cli/en/latest/>
-   example-apps

docs/server/source/quickstart.md

@@ -2,34 +2,55 @@
 
 This page has instructions to set up a single stand-alone BigchainDB node for learning or experimenting. Instructions for other cases are [elsewhere](introduction.html). We will assume you're using Ubuntu 16.04 or similar. If you're not using Linux, then you might try [running BigchainDB with Docker](appendices/run-with-docker.html).
 
-A. [Install RethinkDB Server](https://rethinkdb.com/docs/install/ubuntu/)
+A. Install the database backend. 
 
-B. Open a Terminal and run RethinkDB Server with the command:
+[Install RethinkDB Server](https://rethinkdb.com/docs/install/ubuntu/) or
+[Install MongoDB Server 3.4+](https://docs.mongodb.com/manual/tutorial/install-mongodb-on-ubuntu/)
+
+B. Run the database backend. Open a Terminal and run the command:
+
+with RethinkDB
 ```text
-rethinkdb
+$ rethinkdb
+```
+
+with MongoDB __3.4+__
+```text
+$ mongod --replSet=bigchain-rs
 ```
 
 C. Ubuntu 16.04 already has Python 3.5, so you don't need to install it, but you do need to install some other things:
 ```text
-sudo apt-get update
+$ sudo apt-get update
-sudo apt-get install g++ python3-dev libffi-dev
+$ sudo apt-get install g++ python3-dev libffi-dev
 ```
 
 D. Get the latest version of pip and setuptools:
 ```text
-sudo apt-get install python3-pip
+$ sudo apt-get install python3-pip
-sudo pip3 install --upgrade pip setuptools
+$ sudo pip3 install --upgrade pip setuptools
 ```
 
 E. Install the `bigchaindb` Python package from PyPI:
 ```text
-sudo pip3 install bigchaindb
+$ sudo pip3 install bigchaindb
 ```
 
-F. Configure and run BigchainDB Server:
+F. Configure the BigchainDB Server: and run BigchainDB Server:
+
+with RethinkDB
 ```text
-bigchaindb -y configure
+$ bigchaindb -y configure rethinkdb
-bigchaindb start
+```
+
+with MongoDB
+```text
+$ bigchaindb -y configure mongodb
+```
+
+G. Run the BigchainDB Server:
+```text
+$ bigchaindb start
 ```
 
 That's it!

docs/server/source/server-reference/bigchaindb-cli.md

@@ -15,18 +15,22 @@ Show the version number. `bigchaindb -v` does the same thing.
 
 ## bigchaindb configure
 
-Generate a local config file (which can be used to set some or all [BigchainDB node configuration settings](configuration.html)). It will auto-generate a public-private keypair and then ask you for the values of other configuration settings. If you press Enter for a value, it will use the default value.
+Generate a local configuration file (which can be used to set some or all [BigchainDB node configuration settings](configuration.html)). It will auto-generate a public-private keypair and then ask you for the values of other configuration settings. If you press Enter for a value, it will use the default value.
+
+Since BigchainDB supports multiple databases you need to always specify the
+database backend that you want to use. At this point only two database backends
+are supported: `rethinkdb` and `mongodb`.
 
 If you use the `-c` command-line option, it will generate the file at the specified path:
 ```text
-bigchaindb -c path/to/new_config.json configure
+bigchaindb -c path/to/new_config.json configure rethinkdb
 ```
 
 If you don't use the `-c` command-line option, the file will be written to `$HOME/.bigchaindb` (the default location where BigchainDB looks for a config file, if one isn't specified).
 
 If you use the `-y` command-line option, then there won't be any interactive prompts: it will just generate a keypair and use the default values for all the other configuration settings.
 ```text
-bigchaindb -y configure
+bigchaindb -y configure rethinkdb
 ```
 
 
@@ -83,3 +87,25 @@ Set the number of replicas (of each shard) in the underlying datastore. For exam
 ```text
 $ bigchaindb set-replicas 3
 ```
+
+## bigchaindb add-replicas
+
+This command is specific to MongoDB so it will only run if BigchainDB is
+configured with `mongodb` as the backend.
+
+This command is used to add nodes to a BigchainDB cluster. It accepts a list of
+space separated hosts in the form _hostname:port_:
+```text
+$ bigchaindb add-replicas server1.com:27017 server2.com:27017 server3.com:27017
+```
+
+## bigchaindb remove-replicas
+
+This command is specific to MongoDB so it will only run if BigchainDB is
+configured with `mongodb` as the backend.
+
+This command is used to remove nodes from a BigchainDB cluster. It accepts a
+list of space separated hosts in the form _hostname:port_:
+```text
+$ bigchaindb remove-replicas server1.com:27017 server2.com:27017 server3.com:27017
+```

tests/backend/test_generics.py

@@ -1,6 +1,3 @@
-from importlib import import_module
-from unittest.mock import patch
-
 from pytest import mark, raises
 
 
@@ -69,29 +66,6 @@ def test_changefeed_class(changefeed_class_func_name, args_qty):
         changefeed_class_func(None, *range(args_qty))
 
 
-@mark.parametrize('db,conn_cls', (
-    ('mongodb', 'MongoDBConnection'),
-    ('rethinkdb', 'RethinkDBConnection'),
-))
-@patch('bigchaindb.backend.schema.create_indexes',
-       autospec=True, return_value=None)
-@patch('bigchaindb.backend.schema.create_tables',
-       autospec=True, return_value=None)
-@patch('bigchaindb.backend.schema.create_database',
-       autospec=True, return_value=None)
-def test_init_database(mock_create_database, mock_create_tables,
-                       mock_create_indexes, db, conn_cls):
-    from bigchaindb.backend.schema import init_database
-    conn = getattr(
-        import_module('bigchaindb.backend.{}.connection'.format(db)),
-        conn_cls,
-    )('host', 'port', 'dbname')
-    init_database(connection=conn, dbname='mickeymouse')
-    mock_create_database.assert_called_once_with(conn, 'mickeymouse')
-    mock_create_tables.assert_called_once_with(conn, 'mickeymouse')
-    mock_create_indexes.assert_called_once_with(conn, 'mickeymouse')
-
-
 @mark.parametrize('admin_func_name,kwargs', (
     ('get_config', {'table': None}),
     ('reconfigure', {'table': None, 'shards': None, 'replicas': None}),

tests/commands/test_commands.py

@@ -12,7 +12,8 @@ def test_make_sure_we_dont_remove_any_command():
 
     parser = create_parser()
 
-    assert parser.parse_args(['configure']).command
+    assert parser.parse_args(['configure', 'rethinkdb']).command
+    assert parser.parse_args(['configure', 'mongodb']).command
     assert parser.parse_args(['show-config']).command
     assert parser.parse_args(['export-my-pubkey']).command
     assert parser.parse_args(['init']).command
@@ -31,8 +32,8 @@ def test_start_raises_if_command_not_implemented():
 
     with pytest.raises(NotImplementedError):
         # Will raise because `scope`, the third parameter,
-        # doesn't contain the function `run_configure`
+        # doesn't contain the function `run_start`
-        utils.start(parser, ['configure'], {})
+        utils.start(parser, ['start'], {})
 
 
 def test_start_raises_if_no_arguments_given():
@@ -204,7 +205,7 @@ def test_run_configure_when_config_does_not_exist(monkeypatch,
     from bigchaindb.commands.bigchain import run_configure
     monkeypatch.setattr('os.path.exists', lambda path: False)
     monkeypatch.setattr('builtins.input', lambda: '\n')
-    args = Namespace(config='foo', yes=True)
+    args = Namespace(config='foo', backend='rethinkdb', yes=True)
     return_value = run_configure(args)
     assert return_value is None
 
@@ -228,6 +229,36 @@ def test_run_configure_when_config_does_exist(monkeypatch,
     assert value == {}
 
 
+@pytest.mark.parametrize('backend', (
+    'rethinkdb',
+    'mongodb',
+))
+def test_run_configure_with_backend(backend, monkeypatch, mock_write_config):
+    import bigchaindb
+    from bigchaindb.commands.bigchain import run_configure
+
+    value = {}
+
+    def mock_write_config(new_config, filename=None):
+        value['return'] = new_config
+
+    monkeypatch.setattr('os.path.exists', lambda path: False)
+    monkeypatch.setattr('builtins.input', lambda: '\n')
+    monkeypatch.setattr('bigchaindb.config_utils.write_config',
+                        mock_write_config)
+
+    args = Namespace(config='foo', backend=backend, yes=True)
+    expected_config = bigchaindb.config
+    run_configure(args)
+
+    # update the expected config with the correct backend and keypair
+    backend_conf = getattr(bigchaindb, '_database_' + backend)
+    expected_config.update({'database': backend_conf,
+                            'keypair': value['return']['keypair']})
+
+    assert value['return'] == expected_config
+
+
 @patch('bigchaindb.common.crypto.generate_key_pair',
        return_value=('private_key', 'public_key'))
 @pytest.mark.usefixtures('ignore_local_config_file')

tests/conftest.py

@@ -109,26 +109,23 @@ def _restore_dbs(request):
 
 @pytest.fixture(scope='session')
 def _configure_bigchaindb(request):
+    import bigchaindb
     from bigchaindb import config_utils
     test_db_name = TEST_DB_NAME
     # Put a suffix like _gw0, _gw1 etc on xdist processes
     xdist_suffix = getattr(request.config, 'slaveinput', {}).get('slaveid')
     if xdist_suffix:
         test_db_name = '{}_{}'.format(TEST_DB_NAME, xdist_suffix)
+
+    backend = request.config.getoption('--database-backend')
     config = {
-        'database': {
+        'database': bigchaindb._database_map[backend],
-            'name': test_db_name,
-            'backend': request.config.getoption('--database-backend'),
-        },
         'keypair': {
             'private': '31Lb1ZGKTyHnmVK3LUMrAUrPNfd4sE2YyBt3UA4A25aA',
             'public': '4XYfCbabAWVUCbjTmRTFEu2sc3dFEdkse4r6X498B1s8',
         }
     }
-    # FIXME
+    config['database']['name'] = test_db_name
-    if config['database']['backend'] == 'mongodb':
-        # not a great way to do this
-        config['database']['port'] = 27017
     config_utils.set_config(config)
 
 

tests/test_config_utils.py

@@ -10,24 +10,32 @@ ORIGINAL_CONFIG = copy.deepcopy(bigchaindb._config)
 
 
 @pytest.fixture(scope='function', autouse=True)
-def clean_config(monkeypatch):
+def clean_config(monkeypatch, request):
-    monkeypatch.setattr('bigchaindb.config', copy.deepcopy(ORIGINAL_CONFIG))
+
+    import bigchaindb
+    original_config = copy.deepcopy(ORIGINAL_CONFIG)
+    backend = request.config.getoption('--database-backend')
+    original_config['database'] = bigchaindb._database_map[backend]
+    monkeypatch.setattr('bigchaindb.config', original_config)
 
 
-def test_bigchain_instance_is_initialized_when_conf_provided():
+def test_bigchain_instance_is_initialized_when_conf_provided(request):
+    import bigchaindb
     from bigchaindb import config_utils
     assert 'CONFIGURED' not in bigchaindb.config
 
     config_utils.set_config({'keypair': {'public': 'a', 'private': 'b'}})
 
     assert bigchaindb.config['CONFIGURED'] is True
+
     b = bigchaindb.Bigchain()
 
     assert b.me
     assert b.me_private
 
 
-def test_bigchain_instance_raises_when_not_configured(monkeypatch):
+def test_bigchain_instance_raises_when_not_configured(request, monkeypatch):
+    import bigchaindb
     from bigchaindb import config_utils
     from bigchaindb.common import exceptions
     assert 'CONFIGURED' not in bigchaindb.config
@@ -101,42 +109,64 @@ def test_env_config(monkeypatch):
 
 
 def test_autoconfigure_read_both_from_file_and_env(monkeypatch, request):
+    # constants
+    DATABASE_HOST = 'test-host'
+    DATABASE_NAME = 'test-dbname'
+    DATABASE_PORT = 4242
+    DATABASE_BACKEND = request.config.getoption('--database-backend')
+    SERVER_BIND = '1.2.3.4:56'
+    KEYRING = 'pubkey_0:pubkey_1:pubkey_2'
+
     file_config = {
         'database': {
-            'host': 'test-host',
+            'host': DATABASE_HOST
-            'backend': request.config.getoption('--database-backend')
         },
         'backlog_reassign_delay': 5
     }
     monkeypatch.setattr('bigchaindb.config_utils.file_config', lambda *args, **kwargs: file_config)
-    monkeypatch.setattr('os.environ', {'BIGCHAINDB_DATABASE_NAME': 'test-dbname',
+    monkeypatch.setattr('os.environ', {'BIGCHAINDB_DATABASE_NAME': DATABASE_NAME,
-                                       'BIGCHAINDB_DATABASE_PORT': '4242',
+                                       'BIGCHAINDB_DATABASE_PORT': str(DATABASE_PORT),
-                                       'BIGCHAINDB_SERVER_BIND': '1.2.3.4:56',
+                                       'BIGCHAINDB_DATABASE_BACKEND': DATABASE_BACKEND,
-                                       'BIGCHAINDB_KEYRING': 'pubkey_0:pubkey_1:pubkey_2'})
+                                       'BIGCHAINDB_SERVER_BIND': SERVER_BIND,
+                                       'BIGCHAINDB_KEYRING': KEYRING})
 
     import bigchaindb
     from bigchaindb import config_utils
     config_utils.autoconfigure()
 
+    database_rethinkdb = {
+        'backend': 'rethinkdb',
+        'host': DATABASE_HOST,
+        'port': DATABASE_PORT,
+        'name': DATABASE_NAME,
+    }
+    database_mongodb = {
+        'backend': 'mongodb',
+        'host': DATABASE_HOST,
+        'port': DATABASE_PORT,
+        'name': DATABASE_NAME,
+        'replicaset': 'bigchain-rs',
+    }
+
+    database = {}
+    if DATABASE_BACKEND == 'mongodb':
+        database = database_mongodb
+    elif DATABASE_BACKEND == 'rethinkdb':
+        database = database_rethinkdb
+
     assert bigchaindb.config == {
         'CONFIGURED': True,
         'server': {
-            'bind': '1.2.3.4:56',
+            'bind': SERVER_BIND,
             'workers': None,
             'threads': None,
         },
-        'database': {
+        'database': database,
-            'backend': request.config.getoption('--database-backend'),
-            'host': 'test-host',
-            'port': 4242,
-            'name': 'test-dbname',
-            'replicaset': 'bigchain-rs'
-        },
         'keypair': {
             'public': None,
             'private': None,
         },
-        'keyring': ['pubkey_0', 'pubkey_1', 'pubkey_2'],
+        'keyring': KEYRING.split(':'),
         'statsd': {
             'host': 'localhost',
             'port': 8125,
@@ -215,7 +245,6 @@ def test_write_config():
     ('BIGCHAINDB_DATABASE_HOST', 'test-host', 'host'),
     ('BIGCHAINDB_DATABASE_PORT', 4242, 'port'),
     ('BIGCHAINDB_DATABASE_NAME', 'test-db', 'name'),
-    ('BIGCHAINDB_DATABASE_REPLICASET', 'test-replicaset', 'replicaset')
 ))
 def test_database_envs(env_name, env_value, config_key, monkeypatch):
     import bigchaindb
@@ -227,3 +256,18 @@ def test_database_envs(env_name, env_value, config_key, monkeypatch):
     expected_config['database'][config_key] = env_value
 
     assert bigchaindb.config == expected_config
+
+
+def test_database_envs_replicaset(monkeypatch):
+    # the replica set env is only used if the backend is mongodb
+    import bigchaindb
+
+    monkeypatch.setattr('os.environ', {'BIGCHAINDB_DATABASE_REPLICASET':
+                                       'test-replicaset'})
+    bigchaindb.config['database'] = bigchaindb._database_mongodb
+    bigchaindb.config_utils.autoconfigure()
+
+    expected_config = copy.deepcopy(bigchaindb.config)
+    expected_config['database']['replicaset'] = 'test-replicaset'
+
+    assert bigchaindb.config == expected_config