Merge branch 'master' into abstract_election_class

acceptance/python/Dockerfile

@@ -5,5 +5,5 @@ RUN pip install --upgrade \
 	pycco \
 	websocket-client~=0.47.0 \
 	pytest~=3.0 \
-	bigchaindb-driver==0.5.1 \
+	bigchaindb-driver==0.5.2 \
 	blns

bigchaindb/backend/localmongodb/connection.py

@@ -2,7 +2,6 @@
 # SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0)
 # Code is Apache-2.0 and docs are CC-BY-4.0
 
-import time
 import logging
 from ssl import CERT_REQUIRED
 
@@ -88,23 +87,6 @@ class LocalMongoDBConnection(Connection):
         """
 
         try:
-            if self.replicaset:
-                # we should only return a connection if the replica set is
-                # initialized. initialize_replica_set will check if the
-                # replica set is initialized else it will initialize it.
-                initialize_replica_set(self.host,
-                                       self.port,
-                                       self.connection_timeout,
-                                       self.dbname,
-                                       self.ssl,
-                                       self.login,
-                                       self.password,
-                                       self.ca_cert,
-                                       self.certfile,
-                                       self.keyfile,
-                                       self.keyfile_passphrase,
-                                       self.crlfile)
-
             # FYI: the connection process might raise a
             # `ServerSelectionTimeoutError`, that is a subclass of
             # `ConnectionFailure`.
@@ -140,8 +122,6 @@ class LocalMongoDBConnection(Connection):
 
             return client
 
-        # `initialize_replica_set` might raise `ConnectionFailure`,
-        # `OperationFailure` or `ConfigurationError`.
         except (pymongo.errors.ConnectionFailure,
                 pymongo.errors.OperationFailure) as exc:
             logger.info('Exception in _connect(): {}'.format(exc))
@@ -153,120 +133,3 @@ class LocalMongoDBConnection(Connection):
 MONGO_OPTS = {
     'socketTimeoutMS': 20000,
 }
-
-
-def initialize_replica_set(host, port, connection_timeout, dbname, ssl, login,
-                           password, ca_cert, certfile, keyfile,
-                           keyfile_passphrase, crlfile):
-    """Initialize a replica set. If already initialized skip."""
-
-    # Setup a MongoDB connection
-    # The reason we do this instead of `backend.connect` is that
-    # `backend.connect` will connect you to a replica set but this fails if
-    # you try to connect to a replica set that is not yet initialized
-    try:
-        # The presence of ca_cert, certfile, keyfile, crlfile implies the
-        # use of certificates for TLS connectivity.
-        if ca_cert is None or certfile is None or keyfile is None or \
-                crlfile is None:
-            conn = pymongo.MongoClient(host,
-                                       port,
-                                       serverselectiontimeoutms=connection_timeout,
-                                       ssl=ssl,
-                                       **MONGO_OPTS)
-            if login is not None and password is not None:
-                conn[dbname].authenticate(login, password)
-        else:
-            logger.info('Connecting to MongoDB over TLS/SSL...')
-            conn = pymongo.MongoClient(host,
-                                       port,
-                                       serverselectiontimeoutms=connection_timeout,
-                                       ssl=ssl,
-                                       ssl_ca_certs=ca_cert,
-                                       ssl_certfile=certfile,
-                                       ssl_keyfile=keyfile,
-                                       ssl_pem_passphrase=keyfile_passphrase,
-                                       ssl_crlfile=crlfile,
-                                       ssl_cert_reqs=CERT_REQUIRED,
-                                       **MONGO_OPTS)
-            if login is not None:
-                logger.info('Authenticating to the database...')
-                conn[dbname].authenticate(login, mechanism='MONGODB-X509')
-
-    except (pymongo.errors.ConnectionFailure,
-            pymongo.errors.OperationFailure) as exc:
-        logger.info('Exception in _connect(): {}'.format(exc))
-        raise ConnectionError(str(exc)) from exc
-    except pymongo.errors.ConfigurationError as exc:
-        raise ConfigurationError from exc
-
-    _check_replica_set(conn)
-    host = '{}:{}'.format(bigchaindb.config['database']['host'],
-                          bigchaindb.config['database']['port'])
-    config = {'_id': bigchaindb.config['database']['replicaset'],
-              'members': [{'_id': 0, 'host': host}]}
-
-    try:
-        conn.admin.command('replSetInitiate', config)
-    except pymongo.errors.OperationFailure as exc_info:
-        if exc_info.details['codeName'] == 'AlreadyInitialized':
-            return
-        raise
-    else:
-        _wait_for_replica_set_initialization(conn)
-        logger.info('Initialized replica set')
-    finally:
-        if conn is not None:
-            logger.info('Closing initial connection to MongoDB')
-            conn.close()
-
-
-def _check_replica_set(conn):
-    """Checks if the replSet option was enabled either through the command
-       line option or config file and if it matches the one provided by
-       bigchaindb configuration.
-
-       Note:
-           The setting we are looking for will have a different name depending
-           if it was set by the config file (`replSetName`) or by command
-           line arguments (`replSet`).
-
-        Raise:
-            :exc:`~ConfigurationError`: If mongod was not started with the
-            replSet option.
-    """
-    options = conn.admin.command('getCmdLineOpts')
-    try:
-        repl_opts = options['parsed']['replication']
-        repl_set_name = repl_opts.get('replSetName', repl_opts.get('replSet'))
-    except KeyError:
-        raise ConfigurationError('mongod was not started with'
-                                 ' the replSet option.')
-
-    bdb_repl_set_name = bigchaindb.config['database']['replicaset']
-    if repl_set_name != bdb_repl_set_name:
-        raise ConfigurationError('The replicaset configuration of '
-                                 'bigchaindb (`{}`) needs to match '
-                                 'the replica set name from MongoDB'
-                                 ' (`{}`)'.format(bdb_repl_set_name,
-                                                  repl_set_name))
-
-
-def _wait_for_replica_set_initialization(conn):
-    """Wait for a replica set to finish initialization.
-
-    If a replica set is being initialized for the first time it takes some
-    time. Nodes need to discover each other and an election needs to take
-    place. During this time the database is not writable so we need to wait
-    before continuing with the rest of the initialization
-    """
-
-    # I did not find a better way to do this for now.
-    # To check if the database is ready we will poll the mongodb logs until
-    # we find the line that says the database is ready
-    logger.info('Waiting for mongodb replica set initialization')
-    while True:
-        logs = conn.admin.command('getLog', 'rs')['log']
-        if any('database writes are now permitted' in line for line in logs):
-            return
-        time.sleep(0.1)

bigchaindb/backend/localmongodb/query.py

@@ -296,7 +296,7 @@ def get_validator_set(conn, height=None):
         .limit(1)
     )
 
-    return list(cursor)[0]
+    return next(cursor, None)
 
 
 @register_query(LocalMongoDBConnection)
@@ -322,3 +322,23 @@ def get_asset_tokens_for_public_key(conn, asset_id, public_key):
             {'$project': {'_id': False}}
         ]))
     return cursor
+
+
+@register_query(LocalMongoDBConnection)
+def store_abci_chain(conn, height, chain_id, is_synced=True):
+    return conn.run(
+        conn.collection('abci_chains').replace_one(
+            {'height': height},
+            {'height': height, 'chain_id': chain_id,
+             'is_synced': is_synced},
+            upsert=True,
+        )
+    )
+
+
+@register_query(LocalMongoDBConnection)
+def get_latest_abci_chain(conn):
+    return conn.run(
+        conn.collection('abci_chains')
+            .find_one(projection={'_id': False}, sort=[('height', DESCENDING)])
+    )

bigchaindb/backend/localmongodb/schema.py

@@ -47,6 +47,7 @@ def create_indexes(conn, dbname):
     create_utxos_secondary_index(conn, dbname)
     create_pre_commit_secondary_index(conn, dbname)
     create_validators_secondary_index(conn, dbname)
+    create_abci_chains_indexes(conn, dbname)
     create_elections_secondary_index(conn, dbname)
 
 
@@ -136,9 +137,22 @@ def create_validators_secondary_index(conn, dbname):
                                                  unique=True,)
 
 
+def create_abci_chains_indexes(conn, dbname):
+    logger.info('Create `abci_chains.height` secondary index.')
+
+    conn.conn[dbname]['abci_chains'].create_index('height',
+                                                  name='height',
+                                                  unique=True,)
+
+
 def create_elections_secondary_index(conn, dbname):
     logger.info('Create `elections` secondary index.')
 
     conn.conn[dbname]['elections'].create_index('election_id',
                                                 name='election_id',
                                                 unique=True,)
+
+    logger.info('Create `abci_chains.chain_id` secondary index.')
+    conn.conn[dbname]['abci_chains'].create_index('chain_id',
+                                                  name='chain_id',
+                                                  unique=True)

bigchaindb/backend/query.py

@@ -378,3 +378,23 @@ def get_asset_tokens_for_public_key(connection, asset_id, public_key):
         Iterator of transaction that list given owner in conditions.
     """
     raise NotImplementedError
+
+
+@singledispatch
+def store_abci_chain(conn, height, chain_id, is_synced=True):
+    """Create or update an ABCI chain at the given height.
+    Usually invoked in the beginning of the ABCI communications (height=0)
+    or when ABCI client (like Tendermint) is migrated (any height).
+
+    Args:
+        is_synced: True if the chain is known by both ABCI client and server
+    """
+    raise NotImplementedError
+
+
+@singledispatch
+def get_latest_abci_chain(conn):
+    """Returns the ABCI chain stored at the biggest height, if any,
+    None otherwise.
+    """
+    raise NotImplementedError

bigchaindb/backend/schema.py

@@ -16,7 +16,7 @@ logger = logging.getLogger(__name__)
 
 # Tables/collections that every backend database must create
 TABLES = ('transactions', 'blocks', 'assets', 'metadata',
-          'validators', 'elections', 'pre_commit', 'utxos')
+          'validators', 'elections', 'pre_commit', 'utxos', 'abci_chains')
 
 VALID_LANGUAGES = ('danish', 'dutch', 'english', 'finnish', 'french', 'german',
                    'hungarian', 'italian', 'norwegian', 'portuguese', 'romanian',

bigchaindb/common/transaction.py

@@ -94,7 +94,7 @@ class Input(object):
         """
         try:
             fulfillment = self.fulfillment.serialize_uri()
-        except (TypeError, AttributeError, ASN1EncodeError):
+        except (TypeError, AttributeError, ASN1EncodeError, ASN1DecodeError):
             fulfillment = _fulfillment_to_details(self.fulfillment)
 
         try:
@@ -161,7 +161,7 @@ def _fulfillment_to_details(fulfillment):
     if fulfillment.type_name == 'ed25519-sha-256':
         return {
             'type': 'ed25519-sha-256',
-            'public_key': base58.b58encode(fulfillment.public_key),
+            'public_key': base58.b58encode(fulfillment.public_key).decode(),
         }
 
     if fulfillment.type_name == 'threshold-sha-256':

bigchaindb/core.py

@@ -6,6 +6,7 @@
 with Tendermint.
 """
 import logging
+import sys
 
 from abci.application import BaseApplication
 from abci.types_pb2 import (
@@ -47,22 +48,76 @@ class App(BaseApplication):
         self.block_transactions = []
         self.validators = None
         self.new_height = None
+        self.chain = self.bigchaindb.get_latest_abci_chain()
+
+    def log_abci_migration_error(self, chain_id, validators):
+        logger.error(f'An ABCI chain migration is in process. ' +
+                     'Download the new ABCI client and configure it with ' +
+                     'chain_id={chain_id} and validators={validators}.')
+
+    def abort_if_abci_chain_is_not_synced(self):
+        if self.chain is None or self.chain['is_synced']:
+            return
+
+        validators = self.bigchaindb.get_validators()
+        self.log_abci_migration_error(self.chain['chain_id'], validators)
+        sys.exit(1)
 
     def init_chain(self, genesis):
-        """Initialize chain with block of height 0"""
+        """Initialize chain upon genesis or a migration"""
 
-        validator_set = [vutils.decode_validator(v) for v in genesis.validators]
+        app_hash = ''
-        block = Block(app_hash='', height=0, transactions=[])
+        height = 0
+
+        known_chain = self.bigchaindb.get_latest_abci_chain()
+        if known_chain is not None:
+            chain_id = known_chain['chain_id']
+
+            if known_chain['is_synced']:
+                msg = f'Got invalid InitChain ABCI request ({genesis}) - ' + \
+                      'the chain {chain_id} is already synced.'
+                logger.error(msg)
+                sys.exit(1)
+
+            if chain_id != genesis.chain_id:
+                validators = self.bigchaindb.get_validators()
+                self.log_abci_migration_error(chain_id, validators)
+                sys.exit(1)
+
+            # set migration values for app hash and height
+            block = self.bigchaindb.get_latest_block()
+            app_hash = '' if block is None else block['app_hash']
+            height = 0 if block is None else block['height'] + 1
+
+        known_validators = self.bigchaindb.get_validators()
+        validator_set = [vutils.decode_validator(v)
+                         for v in genesis.validators]
+
+        if known_validators and known_validators != validator_set:
+            self.log_abci_migration_error(known_chain['chain_id'],
+                                          known_validators)
+            sys.exit(1)
+
+        block = Block(app_hash=app_hash, height=height, transactions=[])
         self.bigchaindb.store_block(block._asdict())
-        self.bigchaindb.store_validator_set(1, validator_set, None)
+        self.bigchaindb.store_validator_set(height + 1, validator_set, None)
+        abci_chain_height = 0 if known_chain is None else known_chain['height']
+        self.bigchaindb.store_abci_chain(abci_chain_height,
+                                         genesis.chain_id, True)
+        self.chain = {'height': abci_chain_height, 'is_synced': True,
+                      'chain_id': genesis.chain_id}
         return ResponseInitChain()
 
     def info(self, request):
         """Return height of the latest committed block."""
+
+        self.abort_if_abci_chain_is_not_synced()
+
         r = ResponseInfo()
         block = self.bigchaindb.get_latest_block()
         if block:
-            r.last_block_height = block['height']
+            chain_shift = 0 if self.chain is None else self.chain['height']
+            r.last_block_height = block['height'] - chain_shift
             r.last_block_app_hash = block['app_hash'].encode('utf-8')
         else:
             r.last_block_height = 0
@@ -77,6 +132,8 @@ class App(BaseApplication):
             raw_tx: a raw string (in bytes) transaction.
         """
 
+        self.abort_if_abci_chain_is_not_synced()
+
         logger.benchmark('CHECK_TX_INIT')
         logger.debug('check_tx: %s', raw_transaction)
         transaction = decode_transaction(raw_transaction)
@@ -95,8 +152,11 @@ class App(BaseApplication):
             req_begin_block: block object which contains block header
             and block hash.
         """
+        self.abort_if_abci_chain_is_not_synced()
+
+        chain_shift = 0 if self.chain is None else self.chain['height']
         logger.benchmark('BEGIN BLOCK, height:%s, num_txs:%s',
-                         req_begin_block.header.height,
+                         req_begin_block.header.height + chain_shift,
                          req_begin_block.header.num_txs)
 
         self.block_txn_ids = []
@@ -109,6 +169,9 @@ class App(BaseApplication):
         Args:
             raw_tx: a raw string (in bytes) transaction.
         """
+
+        self.abort_if_abci_chain_is_not_synced()
+
         logger.debug('deliver_tx: %s', raw_transaction)
         transaction = self.bigchaindb.is_valid_transaction(
             decode_transaction(raw_transaction), self.block_transactions)
@@ -130,7 +193,11 @@ class App(BaseApplication):
             height (int): new height of the chain.
         """
 
-        height = request_end_block.height
+        self.abort_if_abci_chain_is_not_synced()
+
+        chain_shift = 0 if self.chain is None else self.chain['height']
+
+        height = request_end_block.height + chain_shift
         self.new_height = height
         block_txn_hash = calculate_hash(self.block_txn_ids)
         block = self.bigchaindb.get_latest_block()
@@ -158,6 +225,8 @@ class App(BaseApplication):
     def commit(self):
         """Store the new height and along with block hash."""
 
+        self.abort_if_abci_chain_is_not_synced()
+
         data = self.block_txn_hash.encode('utf-8')
 
         # register a new block only when new transactions are received

bigchaindb/lib.py

@@ -426,8 +426,7 @@ class BigchainDB(object):
 
     def get_validators(self, height=None):
         result = self.get_validator_change(height)
-        validators = result['validators']
+        return [] if result is None else result['validators']
-        return validators
 
     def get_election_result_by_id(self, election_id, table):
         result = backend.query.get_election_result_by_id(self.connection, election_id, table)
@@ -445,6 +444,37 @@ class BigchainDB(object):
                                                                    'validators': validators,
                                                                    'election_id': election_id})
 
+    def store_abci_chain(self, height, chain_id, is_synced=True):
+        return backend.query.store_abci_chain(self.connection, height,
+                                              chain_id, is_synced)
+
+    def get_latest_abci_chain(self):
+        return backend.query.get_latest_abci_chain(self.connection)
+
+    def migrate_abci_chain(self):
+        """Generate and record a new ABCI chain ID. New blocks are not
+        accepted until we receive an InitChain ABCI request with
+        the matching chain ID and validator set.
+
+        Chain ID is generated based on the current chain and height.
+        `chain-X` => `chain-X-migrated-at-height-5`.
+        `chain-X-migrated-at-height-5` => `chain-X-migrated-at-height-21`.
+
+        If there is no known chain (we are at genesis), the function returns.
+        """
+        latest_chain = self.get_latest_abci_chain()
+        if latest_chain is None:
+            return
+
+        block = self.get_latest_block()
+
+        suffix = '-migrated-at-height-'
+        chain_id = latest_chain['chain_id']
+        block_height_str = str(block['height'])
+        new_chain_id = chain_id.split(suffix)[0] + suffix + block_height_str
+
+        self.store_abci_chain(block['height'] + 1, new_chain_id, False)
+
 
 Block = namedtuple('Block', ('app_hash', 'height', 'transactions'))
 

docs/root/source/decentralized.md

@@ -12,10 +12,6 @@ Ideally, each node in a BigchainDB network is owned and controlled by a differen
 
 We use the phrase "BigchainDB consortium" (or just "consortium") to refer to the set of people and/or organizations who run the nodes of a BigchainDB network. A consortium requires some form of governance to make decisions such as membership and policies. The exact details of the governance process are determined by each consortium, but it can be very decentralized.
 
-If sharding is turned on (i.e. if the number of shards is larger than one), then the actual data is decentralized in that no one node stores all the data.
-
-Every node has its own locally-stored list of the public keys of other consortium members: the so-called keyring. There's no centrally-stored or centrally-shared keyring.
-
 A consortium can increase its decentralization (and its resilience) by increasing its jurisdictional diversity, geographic diversity, and other kinds of diversity. This idea is expanded upon in [the section on node diversity](diversity.html).
 
 There’s no node that has a long-term special position in the BigchainDB network. All nodes run the same software and perform the same duties.

docs/root/source/permissions.rst

@@ -3,6 +3,8 @@
    SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0)
    Code is Apache-2.0 and docs are CC-BY-4.0
 
+.. _permissions-in-bigchaindb:
+
 Permissions in BigchainDB
 -------------------------
 

docs/root/source/smart-contracts.rst

@@ -8,16 +8,8 @@ BigchainDB and Smart Contracts
 
 One can store the source code of any smart contract (i.e. a computer program) in BigchainDB, but BigchainDB won't run arbitrary smart contracts.
 
-BigchainDB will run the subset of smart contracts expressible using `Crypto-Conditions <https://tools.ietf.org/html/draft-thomas-crypto-conditions-03>`_.
+BigchainDB can be used to enforce who has permission to transfer assets, both fungible assets and non-fungible assets. It will prevent double-spending. In other words, a BigchainDB network could be used instead of an ERC-20 (fungible token) or ERC-721 (non-fungible token) smart contract.
 
-The owners of an asset can impose conditions on it that must be met for the asset to be transferred to new owners. Examples of possible conditions (crypto-conditions) include:
+Asset transfer permissions can also be interpreted as write permissions, so they can be used to control who can write to a log, journal or audit trail. There is more about that idea in :ref:`the page about permissions in BigchainDB <permissions-in-bigchaindb>`.
 
-- The current owner must sign the transfer transaction (one which transfers ownership to new owners).
+A BigchainDB network can be connected to other blockchain networks, via oracles or inter-chain communications protocols. That means BigchainDB can be used as part of a solution that uses *other* blockchains to run arbitrary smart contracts.
-- Three out of five current owners must sign the transfer transaction.
-- (Shannon and Kelly) or Morgan must sign the transfer transaction.
-
-Crypto-conditions can be quite complex. They can't include loops or recursion and therefore will always run/check in finite time.
-
-.. note::
-
-   We used the word "owners" somewhat loosely above. A more accurate word might be fulfillers, signers, controllers, or transfer-enablers. See the section titled **A Note about Owners** in the relevant `BigchainDB Transactions Spec <https://github.com/bigchaindb/BEPs/tree/master/tx-specs/>`_.

docs/server/source/appendices/index.rst

@@ -11,9 +11,6 @@ Appendices
 
    json-serialization
    cryptography
-   the-bigchaindb-class
-   backend
-   commands
    aws-setup
    generate-key-pair-for-ssh
    firewall-notes

docs/server/source/code-reference/index.rst

@@ -0,0 +1,24 @@
+
+.. Copyright BigchainDB GmbH and BigchainDB contributors
+   SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0)
+   Code is Apache-2.0 and docs are CC-BY-4.0
+
+Code Reference
+==============
+
+This section contains auto-generated documentation of various functions, classes and methods
+in the BigchainDB Server code, based on Python docstrings in the code itself.
+
+.. warning::
+
+   While we try to keep docstrings accurate,
+   if you want to know *for sure* what the code does,
+   then you have to read the code itself.
+
+.. toctree::
+   :maxdepth: 1
+
+   the-bigchaindb-class
+   backend
+   commands
+   

docs/server/source/index.rst

@@ -23,4 +23,5 @@ BigchainDB Server Documentation
    data-models/index
    k8s-deployment-template/index
    release-notes
+   code-reference/index
    appendices/index

docs/server/source/server-reference/configuration.md

@@ -39,9 +39,34 @@ The settings with names of the form `database.*` are for the backend database
 * `database.name` is a user-chosen name for the database inside MongoDB, e.g. `bigchain`.
 * `database.connection_timeout` is the maximum number of milliseconds that BigchainDB will wait before giving up on one attempt to connect to the backend database.
 * `database.max_tries` is the maximum number of times that BigchainDB will try to establish a connection with the backend database. If 0, then it will try forever.
-* `database.replicaset` is the name of the MongoDB replica set. The default value is `null` because in BighainDB 2.0+, each BigchainDB node has its own independent MongoDB database and no replica set is necessary.
+* `database.replicaset` is the name of the MongoDB replica set. The default value is `null` because in BigchainDB 2.0+, each BigchainDB node has its own independent MongoDB database and no replica set is necessary. Replica set must already exist if this option is configured, BigchainDB will not create it.
-* `database.login` and `database.password` are the login and password used to authenticate to the backend database, specified in plaintext.
+* `database.ssl` must be `true` or `false`. It tells BigchainDB Server whether it should connect to MongoDB using TLS/SSL or not. The default value is `false`.
-* `database.ssl` determines if BigchainDB connects to MongoDB over TLS/SSL or not. It can be set to `true` or `false`.
+
+There are three ways for BigchainDB Server to authenticate itself with MongoDB (or a specific MongoDB database): no authentication, username/password, and x.509 certificate authentication.
+
+**No Authentication**
+
+If you use all the default BigchainDB configuration settings, then no authentication will be used.
+
+**Username/Password Authentication**
+
+To use username/password authentication, a MongoDB instance must already be running somewhere (maybe in another machine), it must already have a database for use by BigchainDB (usually named `bigchain`, which is the default `database.name`), and that database must already have a "readWrite" user with associated username and password. To create such a user, login to your MongoDB instance as Admin and run the following commands:
+
+```text
+use <database.name>
+db.createUser({user: "<database.login>", pwd: "<database.password>", roles: [{role: "readWrite", db: "<database.name>"}]})
+```
+
+* `database.login` is the user's username.
+* `database.password` is the user's password, given in plaintext.
+* `database.ca_cert`, `database.certfile`, `database.keyfile`, `database.crlfile`, and `database.keyfile_passphrase` are not used so they can have their default values.
+
+**x.509 Certificate Authentication**
+
+To use x.509 certificate authentication, a MongoDB instance must be running somewhere (maybe in another machine), it must already have a database for use by BigchainDB (usually named `bigchain`, which is the default `database.name`), and that database must be set up to use x.509 authentication. See the MongoDB docs about how to do that.
+
+* `database.login` is the user's username.
+* `database.password` isn't used so the default value (`null`) is fine.
 * `database.ca_cert`, `database.certfile`, `database.keyfile` and `database.crlfile` are the paths to the CA, signed certificate, private key and certificate revocation list files respectively.
 * `database.keyfile_passphrase` is the private key decryption passphrase, specified in plaintext.
 

setup.py

@@ -79,7 +79,7 @@ install_requires = [
     # TODO Consider not installing the db drivers, or putting them in extras.
     'pymongo~=3.6',
     'pysha3~=1.0.2',
-    'cryptoconditions~=0.6.0.dev',
+    'cryptoconditions~=0.7.2',
     'python-rapidjson~=0.6.0',
     'logstats~=0.2.1',
     'flask>=0.10.1',

tests/README.md

@@ -4,103 +4,13 @@ SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0)
 Code is Apache-2.0 and docs are CC-BY-4.0
 --->
 
-# BigchainDB Server Tests
+# BigchainDB Server Unit Tests
 
-## The tests/ Folder
+Most of the tests in the `tests/` folder are unit tests. For info about how to write and run tests, see [the docs about contributing to BigchainDB](http://docs.bigchaindb.com/projects/contributing/en/latest/index.html), especially:
 
-The `tests/` folder is where all the tests for BigchainDB Server live. Most of them are unit tests. Integration tests are in the [`tests/integration/` folder](./integration/).
+- [Write Code - Remember to Write Tests](http://docs.bigchaindb.com/projects/contributing/en/latest/dev-setup-coding-and-contribution-process/write-code.html#remember-to-write-tests)
+- [Notes on Running a Local Dev Node with Docker Compose](http://docs.bigchaindb.com/projects/contributing/en/latest/dev-setup-coding-and-contribution-process/run-node-with-docker-compose.html), especially `make test`
+- [
+Notes on Running a Local Dev Node as Processes (and Running All Tests)](http://docs.bigchaindb.com/projects/contributing/en/latest/dev-setup-coding-and-contribution-process/run-node-as-processes.html)
 
-A few notes:
+Note: There are acceptance tests in the `acceptance/` folder (at the same level in the hierarchy as the `tests/` folder).
-
-- [`tests/common/`](./common/) contains self-contained tests only testing
-  [`bigchaindb/common/`](../bigchaindb/common/)
-- [`tests/backend/`](./backend/) contains tests requiring
-  the database backend (MongoDB)
-
-
-## Writing Tests
-
-We write unit and integration tests for our Python code using the [pytest](http://pytest.org/latest/) framework. You can use the tests in the `tests/` folder as templates or examples.
-
-
-## Running Tests
-
-### Running Tests Directly
-
-If you installed BigchainDB Server using `pip install bigchaindb`, then you
-didn't install the tests. Before you can run all the tests, you must install
-BigchainDB from source. The [`CONTRIBUTING.md` file](../CONTRIBUTING.md) has
-instructions for how to do that.
-
-Next, make sure you have Local MongoDB running in the background. You
-can run MongoDB using `mongod`.
-
-The `pytest` command has many options. If you want to learn about all the
-things you can do with pytest, see [the pytest
-documentation](http://pytest.org/latest/). We've also added a customization to
-pytest:
-
-`--database-backend`: Defines the backend to use for the tests. It defaults to
-`localmongodb`.
-
-Now you can run all tests using:
-```text
-pytest -v
-```
-
-or, if that doesn't work, try:
-```text
-python -m pytest -v
-```
-
-or:
-```text
-python setup.py test
-```
-
-How does `python setup.py test` work? The documentation for [pytest-runner](https://pypi.python.org/pypi/pytest-runner) explains.
-
-The `pytest` command has many options. If you want to learn about all the things you can do with pytest, see [the pytest documentation](http://pytest.org/latest/). We've also added a customization to pytest:
-
-
-### Running Tests with Docker Compose
-
-You can also use [Docker Compose](https://docs.docker.com/compose/) to run all the tests.
-
-First, bring up all the services BigchainDB, MongoDB, Tendermint in the background:
-
-```text
-$ docker-compose up -d bdb
-```
-
-then run the tests using:
-
-```text
-$ docker-compose run --rm --no-deps bigchaindb pytest -v
-```
-
-## Automated Testing of All Pull Requests
-
-We use [Travis CI](https://travis-ci.com/), so that whenever someone creates a new BigchainDB pull request on GitHub, Travis CI gets the new code and does _a bunch of stuff_. We use the same `docker-compose.yml` for tests. It tells Travis CI how to install BigchainDB, how to run all the tests, and what to do "after success" (e.g. run `codecov`). (We use [Codecov](https://codecov.io/) to get a rough estimate of our test coverage.)
-
-
-### Tox
-
-We use [tox](https://tox.readthedocs.io/en/latest/) to run multiple suites of tests against multiple environments during automated testing. Generally you don't need to run this yourself, but it might be useful when troubleshooting a failing Travis CI build.
-
-To run all the tox tests, use:
-```text
-tox
-```
-
-or:
-```text
-python -m tox
-```
-
-To run only a few environments, use the `-e` flag:
-```text
-tox -e {ENVLIST}
-```
-
-where `{ENVLIST}` is one or more of the environments specified in the [tox.ini file](../tox.ini).

tests/backend/localmongodb/test_connection.py

@@ -7,7 +7,6 @@ from unittest import mock
 import pytest
 import pymongo
 from pymongo import MongoClient
-from pymongo.database import Database
 
 
 pytestmark = [pytest.mark.bdb, pytest.mark.tendermint]
@@ -109,87 +108,3 @@ def test_connection_with_credentials(mock_authenticate):
                                   password='secret')
     conn.connect()
     assert mock_authenticate.call_count == 1
-
-
-def test_check_replica_set_not_enabled(mongodb_connection):
-    from bigchaindb.backend.localmongodb.connection import _check_replica_set
-    from bigchaindb.common.exceptions import ConfigurationError
-
-    # no replSet option set
-    cmd_line_opts = {'argv': ['mongod', '--dbpath=/data'],
-                     'ok': 1.0,
-                     'parsed': {'storage': {'dbPath': '/data'}}}
-    with mock.patch.object(Database, 'command', return_value=cmd_line_opts):
-        with pytest.raises(ConfigurationError):
-            _check_replica_set(mongodb_connection)
-
-
-def test_check_replica_set_command_line(mongodb_connection,
-                                        mock_cmd_line_opts):
-    from bigchaindb.backend.localmongodb.connection import _check_replica_set
-
-    # replSet option set through the command line
-    with mock.patch.object(Database, 'command',
-                           return_value=mock_cmd_line_opts):
-        assert _check_replica_set(mongodb_connection) is None
-
-
-def test_check_replica_set_config_file(mongodb_connection, mock_config_opts):
-    from bigchaindb.backend.localmongodb.connection import _check_replica_set
-
-    # replSet option set through the config file
-    with mock.patch.object(Database, 'command', return_value=mock_config_opts):
-        assert _check_replica_set(mongodb_connection) is None
-
-
-def test_check_replica_set_name_mismatch(mongodb_connection,
-                                         mock_cmd_line_opts):
-    from bigchaindb.backend.localmongodb.connection import _check_replica_set
-    from bigchaindb.common.exceptions import ConfigurationError
-
-    # change the replica set name so it does not match the bigchaindb config
-    mock_cmd_line_opts['parsed']['replication']['replSet'] = 'rs0'
-
-    with mock.patch.object(Database, 'command',
-                           return_value=mock_cmd_line_opts):
-        with pytest.raises(ConfigurationError):
-            _check_replica_set(mongodb_connection)
-
-
-def test_wait_for_replica_set_initialization(mongodb_connection):
-    from bigchaindb.backend.localmongodb.connection import _wait_for_replica_set_initialization  # noqa
-
-    with mock.patch.object(Database, 'command') as mock_command:
-        mock_command.side_effect = [
-            {'log': ['a line']},
-            {'log': ['database writes are now permitted']},
-        ]
-
-        # check that it returns
-        assert _wait_for_replica_set_initialization(mongodb_connection) is None
-
-
-def test_initialize_replica_set(mock_cmd_line_opts):
-    from bigchaindb.backend.localmongodb.connection import initialize_replica_set
-
-    with mock.patch.object(Database, 'command') as mock_command:
-        mock_command.side_effect = [
-            mock_cmd_line_opts,
-            None,
-            {'log': ['database writes are now permitted']},
-        ]
-
-        # check that it returns
-        assert initialize_replica_set('host', 1337, 1000, 'dbname', False, None, None,
-                                      None, None, None, None, None) is None
-
-    # test it raises OperationError if anything wrong
-    with mock.patch.object(Database, 'command') as mock_command:
-        mock_command.side_effect = [
-            mock_cmd_line_opts,
-            pymongo.errors.OperationFailure(None, details={'codeName': ''})
-        ]
-
-        with pytest.raises(pymongo.errors.OperationFailure):
-            initialize_replica_set('host', 1337, 1000, 'dbname', False, None,
-                                   None, None, None, None, None, None) is None

tests/backend/localmongodb/test_queries.py

@@ -7,6 +7,9 @@ from copy import deepcopy
 import pytest
 import pymongo
 
+from bigchaindb.backend import connect, query
+
+
 pytestmark = [pytest.mark.tendermint, pytest.mark.bdb]
 
 
@@ -394,3 +397,51 @@ def test_validator_update():
 
     v91 = query.get_validator_set(conn)
     assert v91['height'] == 91
+
+
+@pytest.mark.parametrize('description,stores,expected', [
+    (
+        'Query empty database.',
+        [],
+        None,
+    ),
+    (
+        'Store one chain with the default value for `is_synced`.',
+        [
+            {'height': 0, 'chain_id': 'some-id'},
+        ],
+        {'height': 0, 'chain_id': 'some-id', 'is_synced': True},
+    ),
+    (
+        'Store one chain with a custom value for `is_synced`.',
+        [
+            {'height': 0, 'chain_id': 'some-id', 'is_synced': False},
+        ],
+        {'height': 0, 'chain_id': 'some-id', 'is_synced': False},
+    ),
+    (
+        'Store one chain, then update it.',
+        [
+            {'height': 0, 'chain_id': 'some-id', 'is_synced': True},
+            {'height': 0, 'chain_id': 'new-id', 'is_synced': False},
+        ],
+        {'height': 0, 'chain_id': 'new-id', 'is_synced': False},
+    ),
+    (
+        'Store a chain, update it, store another chain.',
+        [
+            {'height': 0, 'chain_id': 'some-id', 'is_synced': True},
+            {'height': 0, 'chain_id': 'some-id', 'is_synced': False},
+            {'height': 10, 'chain_id': 'another-id', 'is_synced': True},
+        ],
+        {'height': 10, 'chain_id': 'another-id', 'is_synced': True},
+    ),
+])
+def test_store_abci_chain(description, stores, expected):
+    conn = connect()
+
+    for store in stores:
+        query.store_abci_chain(conn, **store)
+
+    actual = query.get_latest_abci_chain(conn)
+    assert expected == actual, description

tests/backend/localmongodb/test_schema.py

@@ -24,7 +24,7 @@ def test_init_creates_db_tables_and_indexes():
     collection_names = conn.conn[dbname].collection_names()
     assert set(collection_names) == {
         'transactions', 'assets', 'metadata', 'blocks', 'utxos', 'pre_commit',
-        'validators', 'elections'
+        'validators', 'elections', 'abci_chains',
     }
 
     indexes = conn.conn[dbname]['assets'].index_information().keys()
@@ -46,6 +46,9 @@ def test_init_creates_db_tables_and_indexes():
     indexes = conn.conn[dbname]['validators'].index_information().keys()
     assert set(indexes) == {'_id_', 'height'}
 
+    indexes = conn.conn[dbname]['abci_chains'].index_information().keys()
+    assert set(indexes) == {'_id_', 'height', 'chain_id'}
+
     indexes = conn.conn[dbname]['elections'].index_information().keys()
     assert set(indexes) == {'_id_', 'election_id'}
 
@@ -82,7 +85,8 @@ def test_create_tables():
     collection_names = conn.conn[dbname].collection_names()
     assert set(collection_names) == {
         'transactions', 'assets', 'metadata', 'blocks', 'utxos', 'validators', 'elections',
-        'pre_commit'}
+        'pre_commit', 'abci_chains',
+    }
 
 
 def test_create_secondary_indexes():

tests/common/test_transaction.py

@@ -93,7 +93,7 @@ def test_output_serialization(user_Ed25519, user_pub):
             'uri': user_Ed25519.condition_uri,
             'details': {
                 'type': 'ed25519-sha-256',
-                'public_key': b58encode(user_Ed25519.public_key),
+                'public_key': b58encode(user_Ed25519.public_key).decode(),
             },
         },
         'public_keys': [user_pub],
@@ -114,7 +114,7 @@ def test_output_deserialization(user_Ed25519, user_pub):
             'uri': user_Ed25519.condition_uri,
             'details': {
                 'type': 'ed25519-sha-256',
-                'public_key': b58encode(user_Ed25519.public_key),
+                'public_key': b58encode(user_Ed25519.public_key).decode(),
             },
         },
         'public_keys': [user_pub],

tests/tendermint/conftest.py

@@ -16,7 +16,8 @@ def validator_pub_key():
 @pytest.fixture
 def init_chain_request():
     addr = codecs.decode(b'9FD479C869C7D7E7605BF99293457AA5D80C3033', 'hex')
-    pk = codecs.decode(b'VAgFZtYw8bNR5TMZHFOBDWk9cAmEu3/c6JgRBmddbbI=', 'base64')
+    pk = codecs.decode(b'VAgFZtYw8bNR5TMZHFOBDWk9cAmEu3/c6JgRBmddbbI=',
+                       'base64')
     val_a = types.Validator(address=addr, power=10,
                             pub_key=types.PubKey(type='ed25519', data=pk))
 

tests/tendermint/test_core.py

@@ -2,17 +2,28 @@
 # SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0)
 # Code is Apache-2.0 and docs are CC-BY-4.0
 
+import codecs
 import json
 import pytest
+import random
 
 from abci.types_pb2 import (
+    PubKey,
+    ResponseInitChain,
+    RequestInitChain,
+    RequestInfo,
     RequestBeginBlock,
-    RequestEndBlock
+    RequestEndBlock,
+    Validator,
 )
 
+from bigchaindb import App
+from bigchaindb.backend.localmongodb import query
+from bigchaindb.common.crypto import generate_key_pair
 from bigchaindb.core import (CodeTypeOk,
                              CodeTypeError,
                              )
+from bigchaindb.lib import Block
 from bigchaindb.upsert_validator.validator_utils import new_validator_set
 from bigchaindb.tendermint_utils import public_key_to_base64
 
@@ -24,6 +35,173 @@ def encode_tx_to_bytes(transaction):
     return json.dumps(transaction.to_dict()).encode('utf8')
 
 
+def generate_address():
+    return ''.join(random.choices('1,2,3,4,5,6,7,8,9,A,B,C,D,E,F'.split(','),
+                                  k=40)).encode()
+
+
+def generate_validator():
+    addr = codecs.decode(generate_address(), 'hex')
+    pk, _ = generate_key_pair()
+    pub_key = PubKey(type='ed25519', data=pk.encode())
+    val = Validator(address=addr, power=10, pub_key=pub_key)
+    return val
+
+
+def generate_init_chain_request(chain_id, vals=None):
+    vals = vals if vals is not None else [generate_validator()]
+    return RequestInitChain(validators=vals, chain_id=chain_id)
+
+
+def test_init_chain_successfully_registers_chain(b):
+    request = generate_init_chain_request('chain-XYZ')
+    res = App(b).init_chain(request)
+    assert res == ResponseInitChain()
+    chain = query.get_latest_abci_chain(b.connection)
+    assert chain == {'height': 0, 'chain_id': 'chain-XYZ', 'is_synced': True}
+    assert query.get_latest_block(b.connection) == {
+        'height': 0,
+        'app_hash': '',
+        'transactions': [],
+    }
+
+
+def test_init_chain_ignores_invalid_init_chain_requests(b):
+    validators = [generate_validator()]
+    request = generate_init_chain_request('chain-XYZ', validators)
+    res = App(b).init_chain(request)
+    assert res == ResponseInitChain()
+
+    validator_set = query.get_validator_set(b.connection)
+
+    invalid_requests = [
+        request,  # the same request again
+        # different validator set
+        generate_init_chain_request('chain-XYZ'),
+        # different chain ID
+        generate_init_chain_request('chain-ABC', validators),
+    ]
+    for r in invalid_requests:
+        with pytest.raises(SystemExit):
+            App(b).init_chain(r)
+        # assert nothing changed - neither validator set, nor chain ID
+        new_validator_set = query.get_validator_set(b.connection)
+        assert new_validator_set == validator_set
+        new_chain_id = query.get_latest_abci_chain(b.connection)['chain_id']
+        assert new_chain_id == 'chain-XYZ'
+        assert query.get_latest_block(b.connection) == {
+            'height': 0,
+            'app_hash': '',
+            'transactions': [],
+        }
+
+
+def test_init_chain_recognizes_new_chain_after_migration(b):
+    validators = [generate_validator()]
+    request = generate_init_chain_request('chain-XYZ', validators)
+    res = App(b).init_chain(request)
+    assert res == ResponseInitChain()
+
+    validator_set = query.get_validator_set(b.connection)['validators']
+
+    # simulate a migration
+    query.store_block(b.connection, Block(app_hash='', height=1,
+                                          transactions=[])._asdict())
+    b.migrate_abci_chain()
+
+    # the same or other mismatching requests are ignored
+    invalid_requests = [
+        request,
+        generate_init_chain_request('unknown', validators),
+        generate_init_chain_request('chain-XYZ'),
+        generate_init_chain_request('chain-XYZ-migrated-at-height-1'),
+    ]
+    for r in invalid_requests:
+        with pytest.raises(SystemExit):
+            App(b).init_chain(r)
+        assert query.get_latest_abci_chain(b.connection) == {
+            'chain_id': 'chain-XYZ-migrated-at-height-1',
+            'is_synced': False,
+            'height': 2,
+        }
+        new_validator_set = query.get_validator_set(b.connection)['validators']
+        assert new_validator_set == validator_set
+
+    # a request with the matching chain ID and matching validator set
+    # completes the migration
+    request = generate_init_chain_request('chain-XYZ-migrated-at-height-1',
+                                          validators)
+    res = App(b).init_chain(request)
+    assert res == ResponseInitChain()
+    assert query.get_latest_abci_chain(b.connection) == {
+        'chain_id': 'chain-XYZ-migrated-at-height-1',
+        'is_synced': True,
+        'height': 2,
+    }
+    assert query.get_latest_block(b.connection) == {
+        'height': 2,
+        'app_hash': '',
+        'transactions': [],
+    }
+
+    # requests with old chain ID and other requests are ignored
+    invalid_requests = [
+        request,
+        generate_init_chain_request('chain-XYZ', validators),
+        generate_init_chain_request('chain-XYZ-migrated-at-height-1'),
+    ]
+    for r in invalid_requests:
+        with pytest.raises(SystemExit):
+            App(b).init_chain(r)
+        assert query.get_latest_abci_chain(b.connection) == {
+            'chain_id': 'chain-XYZ-migrated-at-height-1',
+            'is_synced': True,
+            'height': 2,
+        }
+        new_validator_set = query.get_validator_set(b.connection)['validators']
+        assert new_validator_set == validator_set
+        assert query.get_latest_block(b.connection) == {
+            'height': 2,
+            'app_hash': '',
+            'transactions': [],
+        }
+
+
+def test_info(b):
+    r = RequestInfo()
+    app = App(b)
+
+    res = app.info(r)
+    assert res.last_block_height == 0
+    assert res.last_block_app_hash == b''
+
+    b.store_block(Block(app_hash='1', height=1, transactions=[])._asdict())
+    res = app.info(r)
+    assert res.last_block_height == 1
+    assert res.last_block_app_hash == b'1'
+
+    # simulate a migration and assert the height is shifted
+    b.store_abci_chain(2, 'chain-XYZ')
+    app = App(b)
+    b.store_block(Block(app_hash='2', height=2, transactions=[])._asdict())
+    res = app.info(r)
+    assert res.last_block_height == 0
+    assert res.last_block_app_hash == b'2'
+
+    b.store_block(Block(app_hash='3', height=3, transactions=[])._asdict())
+    res = app.info(r)
+    assert res.last_block_height == 1
+    assert res.last_block_app_hash == b'3'
+
+    # it's always the latest migration that is taken into account
+    b.store_abci_chain(4, 'chain-XYZ-new')
+    app = App(b)
+    b.store_block(Block(app_hash='4', height=4, transactions=[])._asdict())
+    res = app.info(r)
+    assert res.last_block_height == 0
+    assert res.last_block_app_hash == b'4'
+
+
 def test_check_tx__signed_create_is_ok(b):
     from bigchaindb import App
     from bigchaindb.models import Transaction
@@ -57,7 +235,6 @@ def test_check_tx__unsigned_create_is_error(b):
     assert result.code == CodeTypeError
 
 
-@pytest.mark.bdb
 def test_deliver_tx__valid_create_updates_db(b, init_chain_request):
     from bigchaindb import App
     from bigchaindb.models import Transaction
@@ -225,6 +402,17 @@ def test_store_pre_commit_state_in_end_block(b, alice, init_chain_request):
     assert resp['height'] == 100
     assert resp['transactions'] == [tx.id]
 
+    # simulate a chain migration and assert the height is shifted
+    b.store_abci_chain(100, 'new-chain')
+    app = App(b)
+    app.begin_block(begin_block)
+    app.deliver_tx(encode_tx_to_bytes(tx))
+    app.end_block(RequestEndBlock(height=1))
+    resp = query.get_pre_commit_state(b.connection, PRE_COMMIT_ID)
+    assert resp['commit_id'] == PRE_COMMIT_ID
+    assert resp['height'] == 101
+    assert resp['transactions'] == [tx.id]
+
 
 def test_new_validator_set(b):
     node1 = {'pub_key': {'type': 'ed25519',
@@ -247,3 +435,45 @@ def test_new_validator_set(b):
                                    'voting_power':  u['power']})
 
     assert updated_validator_set == updated_validators
+
+
+def test_info_aborts_if_chain_is_not_synced(b):
+    b.store_abci_chain(0, 'chain-XYZ', False)
+
+    with pytest.raises(SystemExit):
+        App(b).info(RequestInfo())
+
+
+def test_check_tx_aborts_if_chain_is_not_synced(b):
+    b.store_abci_chain(0, 'chain-XYZ', False)
+
+    with pytest.raises(SystemExit):
+        App(b).check_tx('some bytes')
+
+
+def test_begin_aborts_if_chain_is_not_synced(b):
+    b.store_abci_chain(0, 'chain-XYZ', False)
+
+    with pytest.raises(SystemExit):
+        App(b).info(RequestBeginBlock())
+
+
+def test_deliver_tx_aborts_if_chain_is_not_synced(b):
+    b.store_abci_chain(0, 'chain-XYZ', False)
+
+    with pytest.raises(SystemExit):
+        App(b).deliver_tx('some bytes')
+
+
+def test_end_block_aborts_if_chain_is_not_synced(b):
+    b.store_abci_chain(0, 'chain-XYZ', False)
+
+    with pytest.raises(SystemExit):
+        App(b).info(RequestEndBlock())
+
+
+def test_commit_aborts_if_chain_is_not_synced(b):
+    b.store_abci_chain(0, 'chain-XYZ', False)
+
+    with pytest.raises(SystemExit):
+        App(b).commit()

tests/tendermint/test_lib.py

@@ -15,6 +15,7 @@ import pytest
 from pymongo import MongoClient
 
 from bigchaindb import backend
+from bigchaindb.lib import Block
 
 
 pytestmark = pytest.mark.tendermint
@@ -441,3 +442,35 @@ def test_validation_with_transaction_buffer(b):
     assert not b.is_valid_transaction(create_tx, [create_tx])
     assert not b.is_valid_transaction(transfer_tx, [create_tx, transfer_tx])
     assert not b.is_valid_transaction(double_spend, [create_tx, transfer_tx])
+
+
+@pytest.mark.bdb
+def test_migrate_abci_chain_yields_on_genesis(b):
+    b.migrate_abci_chain()
+    latest_chain = b.get_latest_abci_chain()
+    assert latest_chain is None
+
+
+@pytest.mark.bdb
+@pytest.mark.parametrize('chain,block_height,expected', [
+    (
+        (1, 'chain-XYZ', True),
+        4,
+        {'height': 5, 'chain_id': 'chain-XYZ-migrated-at-height-4',
+         'is_synced': False},
+    ),
+    (
+        (5, 'chain-XYZ-migrated-at-height-4', True),
+        13,
+        {'height': 14, 'chain_id': 'chain-XYZ-migrated-at-height-13',
+         'is_synced': False},
+    ),
+])
+def test_migrate_abci_chain_generates_new_chains(b, chain, block_height,
+                                                 expected):
+    b.store_abci_chain(*chain)
+    b.store_block(Block(app_hash='', height=block_height,
+                        transactions=[])._asdict())
+    b.migrate_abci_chain()
+    latest_chain = b.get_latest_abci_chain()
+    assert latest_chain == expected

tests/tendermint/test_utils.py

@@ -12,6 +12,7 @@ except ImportError:
 
 import pytest
 
+
 pytestmark = pytest.mark.tendermint
 
 

tests/utils.py

@@ -5,6 +5,7 @@
 from functools import singledispatch
 
 from bigchaindb.backend.localmongodb.connection import LocalMongoDBConnection
+from bigchaindb.backend.schema import TABLES
 
 
 @singledispatch
@@ -14,13 +15,8 @@ def flush_db(connection, dbname):
 
 @flush_db.register(LocalMongoDBConnection)
 def flush_localmongo_db(connection, dbname):
-    connection.conn[dbname].bigchain.delete_many({})
+    for t in TABLES:
-    connection.conn[dbname].blocks.delete_many({})
+        getattr(connection.conn[dbname], t).delete_many({})
-    connection.conn[dbname].transactions.delete_many({})
-    connection.conn[dbname].assets.delete_many({})
-    connection.conn[dbname].metadata.delete_many({})
-    connection.conn[dbname].utxos.delete_many({})
-    connection.conn[dbname].validators.delete_many({})
 
 
 def generate_block(bigchain):