Mirroristas/bigchaindb
2
0
Fork 0
mirror of https://github.com/bigchaindb/bigchaindb.git synced 2024-10-13 13:34:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #2092 from muawiakh/migrate-cli

Browse Source 
Migrate cli for tendermint integration
This commit is contained in:
Ahmed Muawia Khan 2018-02-28 14:44:43 +01:00 committed by GitHub
commit 5f06ad5493
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 49 additions and 585 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

163
bigchaindb/commands/bigchaindb.py
View File

@ -10,21 +10,16 @@ import json
import sys import sys
from bigchaindb.common import crypto from bigchaindb.common import crypto
from bigchaindb.common.exceptions import (StartupError, from bigchaindb.common.exceptions import (DatabaseAlreadyExists,
DatabaseAlreadyExists,
KeypairNotFoundException, KeypairNotFoundException,
DatabaseDoesNotExist) DatabaseDoesNotExist)
import bigchaindb import bigchaindb
from bigchaindb import backend from bigchaindb import backend
from bigchaindb.backend import schema from bigchaindb.backend import schema
from bigchaindb.backend import query from bigchaindb.backend import query
from bigchaindb.backend.admin import (set_replicas, set_shards, add_replicas,
remove_replicas)
from bigchaindb.backend.exceptions import OperationError
from bigchaindb.commands import utils from bigchaindb.commands import utils
from bigchaindb.commands.messages import ( from bigchaindb.commands.messages import (
CANNOT_START_KEYPAIR_NOT_FOUND, CANNOT_START_KEYPAIR_NOT_FOUND,
RETHINKDB_STARTUP_ERROR,
) )
from bigchaindb.commands.utils import ( from bigchaindb.commands.utils import (
configure_bigchaindb, start_logging_process, input_on_stderr) configure_bigchaindb, start_logging_process, input_on_stderr)
@ -79,8 +74,8 @@ def run_configure(args, skip_if_exists=False):
# Patch the default configuration with the new values # Patch the default configuration with the new values
conf = bigchaindb.config_utils.update( conf = bigchaindb.config_utils.update(
conf, conf,
bigchaindb.config_utils.env_config(bigchaindb.config)) bigchaindb.config_utils.env_config(bigchaindb.config))
print('Generating keypair', file=sys.stderr) print('Generating keypair', file=sys.stderr)
conf['keypair']['private'], conf['keypair']['public'] = \ conf['keypair']['private'], conf['keypair']['public'] = \
@ -95,15 +90,18 @@ def run_configure(args, skip_if_exists=False):
if not args.yes: if not args.yes:
for key in ('bind', ): for key in ('bind', ):
val = conf['server'][key] val = conf['server'][key]
conf['server'][key] = input_on_stderr('API Server {}? (default `{}`): '.format(key, val), val) conf['server'][key] = input_on_stderr(
'API Server {}? (default `{}`): '.format(key, val), val)
for key in ('scheme', 'host', 'port'): for key in ('scheme', 'host', 'port'):
val = conf['wsserver'][key] val = conf['wsserver'][key]
conf['wsserver'][key] = input_on_stderr('WebSocket Server {}? (default `{}`): '.format(key, val), val) conf['wsserver'][key] = input_on_stderr(
'WebSocket Server {}? (default `{}`): '.format(key, val), val)
for key in database_keys: for key in database_keys:
val = conf['database'][key] val = conf['database'][key]
conf['database'][key] = input_on_stderr('Database {}? (default `{}`): '.format(key, val), val) conf['database'][key] = input_on_stderr(
'Database {}? (default `{}`): '.format(key, val), val)
val = conf['backlog_reassign_delay'] val = conf['backlog_reassign_delay']
conf['backlog_reassign_delay'] = input_on_stderr( conf['backlog_reassign_delay'] = input_on_stderr(
@ -117,21 +115,6 @@ def run_configure(args, skip_if_exists=False):
print('Ready to go!', file=sys.stderr) print('Ready to go!', file=sys.stderr)
@configure_bigchaindb
def run_export_my_pubkey(args):
"""Export this node's public key to standard output
"""
pubkey = bigchaindb.config['keypair']['public']
if pubkey is not None:
print(pubkey)
else:
sys.exit("This node's public key wasn't set anywhere "
"so it can't be exported")
# raises SystemExit exception
# message is sent to stderr
# exits with exit code 1 (signals tha an error happened)
def _run_init(): def _run_init():
# Try to access the keypair, throws an exception if it does not exist # Try to access the keypair, throws an exception if it does not exist
b = bigchaindb.Bigchain() b = bigchaindb.Bigchain()
@ -163,7 +146,8 @@ def run_recover(b):
if block: if block:
while block['height'] > tendermint_height: while block['height'] > tendermint_height:
logger.info('BigchainDB is ahead of tendermint, removing block %s', block['height']) logger.info(
'BigchainDB is ahead of tendermint, removing block %s', block['height'])
query.delete_latest_block(b.connection) query.delete_latest_block(b.connection)
block = b.get_latest_block() block = b.get_latest_block()
@ -174,7 +158,8 @@ def run_drop(args):
dbname = bigchaindb.config['database']['name'] dbname = bigchaindb.config['database']['name']
if not args.yes: if not args.yes:
response = input_on_stderr('Do you want to drop `{}` database? [y/n]: '.format(dbname)) response = input_on_stderr(
'Do you want to drop `{}` database? [y/n]: '.format(dbname))
if response != 'y': if response != 'y':
return return
@ -183,7 +168,8 @@ def run_drop(args):
try: try:
schema.drop_database(conn, dbname) schema.drop_database(conn, dbname)
except DatabaseDoesNotExist: except DatabaseDoesNotExist:
print("Cannot drop '{name}'. The database does not exist.".format(name=dbname), file=sys.stderr) print("Cannot drop '{name}'. The database does not exist.".format(
name=dbname), file=sys.stderr)
@configure_bigchaindb @configure_bigchaindb
@ -194,22 +180,7 @@ def run_start(args):
# run_recover(BigchainDB()) # run_recover(BigchainDB())
if args.allow_temp_keypair: logger.info('Keypair found, no need to create one on the fly.')
if not (bigchaindb.config['keypair']['private'] or
bigchaindb.config['keypair']['public']):
private_key, public_key = crypto.generate_key_pair()
bigchaindb.config['keypair']['private'] = private_key
bigchaindb.config['keypair']['public'] = public_key
else:
logger.warning('Keypair found, no need to create one on the fly.')
if args.start_rethinkdb:
try:
proc = utils.start_rethinkdb()
except StartupError as e:
sys.exit(RETHINKDB_STARTUP_ERROR.format(e))
logger.info('RethinkDB started with PID %s' % proc.pid)
try: try:
if not args.skip_initialize_database: if not args.skip_initialize_database:
@ -226,50 +197,6 @@ def run_start(args):
start() start()
@configure_bigchaindb
def run_set_shards(args):
conn = backend.connect()
try:
set_shards(conn, shards=args.num_shards)
except OperationError as e:
sys.exit(str(e))
@configure_bigchaindb
def run_set_replicas(args):
conn = backend.connect()
try:
set_replicas(conn, replicas=args.num_replicas)
except OperationError as e:
sys.exit(str(e))
@configure_bigchaindb
def run_add_replicas(args):
# Note: This command is specific to MongoDB
conn = backend.connect()
try:
add_replicas(conn, args.replicas)
except (OperationError, NotImplementedError) as e:
sys.exit(str(e))
else:
print('Added {} to the replicaset.'.format(args.replicas))
@configure_bigchaindb
def run_remove_replicas(args):
# Note: This command is specific to MongoDB
conn = backend.connect()
try:
remove_replicas(conn, args.replicas)
except (OperationError, NotImplementedError) as e:
sys.exit(str(e))
else:
print('Removed {} from the replicaset.'.format(args.replicas))
def create_parser(): def create_parser():
parser = argparse.ArgumentParser( parser = argparse.ArgumentParser(
description='Control your BigchainDB node.', description='Control your BigchainDB node.',
@ -291,16 +218,13 @@ def create_parser():
default='localmongodb', default='localmongodb',
const='localmongodb', const='localmongodb',
nargs='?', nargs='?',
help='The backend to use. It can be either ' help='The backend to use. It can only be '
'rethinkdb or mongodb.') '"localmongodb", currently.')
# parsers for showing/exporting config values # parsers for showing/exporting config values
subparsers.add_parser('show-config', subparsers.add_parser('show-config',
help='Show the current configuration') help='Show the current configuration')
subparsers.add_parser('export-my-pubkey',
help="Export this node's public key")
# parser for database-level commands # parser for database-level commands
subparsers.add_parser('init', subparsers.add_parser('init',
help='Init the database') help='Init the database')
@ -312,63 +236,12 @@ def create_parser():
start_parser = subparsers.add_parser('start', start_parser = subparsers.add_parser('start',
help='Start BigchainDB') help='Start BigchainDB')
start_parser.add_argument('--dev-allow-temp-keypair',
dest='allow_temp_keypair',
action='store_true',
help='Generate a random keypair on start')
start_parser.add_argument('--dev-start-rethinkdb',
dest='start_rethinkdb',
action='store_true',
help='Run RethinkDB on start')
start_parser.add_argument('--no-init', start_parser.add_argument('--no-init',
dest='skip_initialize_database', dest='skip_initialize_database',
default=False, default=False,
action='store_true', action='store_true',
help='Skip database initialization') help='Skip database initialization')
# parser for configuring the number of shards
sharding_parser = subparsers.add_parser('set-shards',
help='Configure number of shards')
sharding_parser.add_argument('num_shards', metavar='num_shards',
type=int, default=1,
help='Number of shards')
# parser for configuring the number of replicas
replicas_parser = subparsers.add_parser('set-replicas',
help='Configure number of replicas')
replicas_parser.add_argument('num_replicas', metavar='num_replicas',
type=int, default=1,
help='Number of replicas (i.e. the replication factor)')
# parser for adding nodes to the replica set
add_replicas_parser = subparsers.add_parser('add-replicas',
help='Add a set of nodes to the '
'replica set. This command '
'is specific to the MongoDB'
' backend.')
add_replicas_parser.add_argument('replicas', nargs='+',
type=utils.mongodb_host,
help='A list of space separated hosts to '
'add to the replicaset. Each host '
'should be in the form `host:port`.')
# parser for removing nodes from the replica set
rm_replicas_parser = subparsers.add_parser('remove-replicas',
help='Remove a set of nodes from the '
'replica set. This command '
'is specific to the MongoDB'
' backend.')
rm_replicas_parser.add_argument('replicas', nargs='+',
type=utils.mongodb_host,
help='A list of space separated hosts to '
'remove from the replicaset. Each host '
'should be in the form `host:port`.')
return parser return parser

77
bigchaindb/commands/utils.py
View File

@ -6,16 +6,10 @@ import argparse
import builtins import builtins
import functools import functools
import multiprocessing as mp import multiprocessing as mp
import subprocess
import sys import sys
import rethinkdb as r
from pymongo import uri_parser
import bigchaindb import bigchaindb
import bigchaindb.config_utils import bigchaindb.config_utils
from bigchaindb import backend
from bigchaindb.common.exceptions import StartupError
from bigchaindb.log.setup import setup_logging from bigchaindb.log.setup import setup_logging
from bigchaindb.version import __version__ from bigchaindb.version import __version__
@ -125,46 +119,6 @@ def input_on_stderr(prompt='', default=None, convert=None):
return _convert(value, default, convert) return _convert(value, default, convert)
def start_rethinkdb():
"""Start RethinkDB as a child process and wait for it to be
available.
Raises:
:class:`~bigchaindb.common.exceptions.StartupError` if
RethinkDB cannot be started.
"""
proc = subprocess.Popen(['rethinkdb', '--bind', 'all'],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
universal_newlines=True)
dbname = bigchaindb.config['database']['name']
line = ''
for line in proc.stdout:
if line.startswith('Server ready'):
# FIXME: seems like tables are not ready when the server is ready,
# that's why we need to query RethinkDB to know the state
# of the database. This code assumes the tables are ready
# when the database is ready. This seems a valid assumption.
try:
conn = backend.connect()
# Before checking if the db is ready, we need to query
# the server to check if it contains that db
if conn.run(r.db_list().contains(dbname)):
conn.run(r.db(dbname).wait())
except (r.ReqlOpFailedError, r.ReqlDriverError) as exc:
raise StartupError('Error waiting for the database `{}` '
'to be ready'.format(dbname)) from exc
return proc
# We are here when we exhaust the stdout of the process.
# The last `line` contains info about the error.
raise StartupError(line)
def start(parser, argv, scope): def start(parser, argv, scope):
"""Utility function to execute a subcommand. """Utility function to execute a subcommand.
@ -206,34 +160,6 @@ def start(parser, argv, scope):
return func(args) return func(args)
def mongodb_host(host):
"""Utility function that works as a type for mongodb ``host`` args.
This function validates the ``host`` args provided by to the
``add-replicas`` and ``remove-replicas`` commands and checks if each arg
is in the form "host:port"
Args:
host (str): A string containing hostname and port (e.g. "host:port")
Raises:
ArgumentTypeError: if it fails to parse the argument
"""
# check if mongodb can parse the host
try:
hostname, port = uri_parser.parse_host(host, default_port=None)
except ValueError as exc:
raise argparse.ArgumentTypeError(exc.args[0])
# we do require the port to be provided.
if port is None or hostname == '':
raise argparse.ArgumentTypeError('expected host in the form '
'`host:port`. Got `{}` instead.'
.format(host))
return host
base_parser = argparse.ArgumentParser(add_help=False, prog='bigchaindb') base_parser = argparse.ArgumentParser(add_help=False, prog='bigchaindb')
base_parser.add_argument('-c', '--config', base_parser.add_argument('-c', '--config',
@ -244,7 +170,8 @@ base_parser.add_argument('-c', '--config',
# the environment variables provided to configure the logger. # the environment variables provided to configure the logger.
base_parser.add_argument('-l', '--log-level', base_parser.add_argument('-l', '--log-level',
type=str.upper, # convert to uppercase for comparison to choices type=str.upper, # convert to uppercase for comparison to choices
choices=['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'], choices=['DEBUG', 'INFO',
'WARNING', 'ERROR', 'CRITICAL'],
help='Log level') help='Log level')
base_parser.add_argument('-y', '--yes', '--yes-please', base_parser.add_argument('-y', '--yes', '--yes-please',

3
compose/travis/Dockerfile
View File

@ -12,11 +12,8 @@ ENV PYTHONUNBUFFERED 0
ENV BIGCHAINDB_DATABASE_PORT 27017 ENV BIGCHAINDB_DATABASE_PORT 27017
ENV BIGCHAINDB_DATABASE_BACKEND $backend ENV BIGCHAINDB_DATABASE_BACKEND $backend
ENV BIGCHAINDB_SERVER_BIND 0.0.0.0:9984
ENV BIGCHAINDB_WSSERVER_HOST 0.0.0.0
ENV BIGCHAINDB_WSSERVER_SCHEME ws ENV BIGCHAINDB_WSSERVER_SCHEME ws
ENV BIGCHAINDB_WSSERVER_ADVERTISED_HOST 0.0.0.0
ENV BIGCHAINDB_WSSERVER_ADVERTISED_SCHEME ws ENV BIGCHAINDB_WSSERVER_ADVERTISED_SCHEME ws
ENV BIGCHAINDB_START_TENDERMINT 0 ENV BIGCHAINDB_START_TENDERMINT 0

2
docker-compose.travis.yml
View File

@ -19,8 +19,6 @@ services:
BIGCHAINDB_DATABASE_BACKEND: localmongodb BIGCHAINDB_DATABASE_BACKEND: localmongodb
BIGCHAINDB_DATABASE_HOST: mdb BIGCHAINDB_DATABASE_HOST: mdb
BIGCHAINDB_DATABASE_PORT: 27017 BIGCHAINDB_DATABASE_PORT: 27017
BIGCHAINDB_SERVER_BIND: 0.0.0.0:9984
BIGCHAINDB_WSSERVER_HOST: 0.0.0.0
BIGCHAINDB_START_TENDERMINT: 0 BIGCHAINDB_START_TENDERMINT: 0
BIGCHAINDB_TENDERMINT_HOST: tendermint BIGCHAINDB_TENDERMINT_HOST: tendermint
BIGCHAINDB_TENDERMINT_PORT: 46657 BIGCHAINDB_TENDERMINT_PORT: 46657

2
tests/commands/conftest.py
View File

@ -47,8 +47,6 @@ def run_start_args(request):
param = getattr(request, 'param', {}) param = getattr(request, 'param', {})
return Namespace( return Namespace(
config=param.get('config'), config=param.get('config'),
start_rethinkdb=param.get('start_rethinkdb', False),
allow_temp_keypair=param.get('allow_temp_keypair', False),
skip_initialize_database=param.get('skip_initialize_database', False), skip_initialize_database=param.get('skip_initialize_database', False),
) )

0
tests/commands/rethinkdb/__init__.py
View File

125
tests/commands/rethinkdb/test_commands.py
View File

@ -1,125 +0,0 @@
import pytest
import rethinkdb
from unittest.mock import Mock, patch
from argparse import Namespace
@patch('bigchaindb.commands.utils.start_rethinkdb', return_value=Mock())
def test_bigchain_run_start_with_rethinkdb(mock_start_rethinkdb,
mock_run_configure,
mock_processes_start,
mock_db_init_with_existing_db,
mocked_setup_logging):
from bigchaindb import config
from bigchaindb.commands.bigchaindb import run_start
args = Namespace(start_rethinkdb=True, allow_temp_keypair=False, config=None, yes=True,
skip_initialize_database=False)
run_start(args)
mock_start_rethinkdb.assert_called_with()
mocked_setup_logging.assert_called_once_with(user_log_config=config['log'])
@patch('subprocess.Popen')
def test_start_rethinkdb_returns_a_process_when_successful(mock_popen):
from bigchaindb.commands import utils
mock_popen.return_value = Mock(stdout=[
'Listening for client driver 1234',
'Server ready'])
assert utils.start_rethinkdb() is mock_popen.return_value
@patch('subprocess.Popen')
def test_start_rethinkdb_exits_when_cannot_start(mock_popen):
from bigchaindb.common import exceptions
from bigchaindb.commands import utils
mock_popen.return_value = Mock(stdout=['Nopety nope'])
with pytest.raises(exceptions.StartupError):
utils.start_rethinkdb()
@patch('rethinkdb.ast.Table.reconfigure')
def test_set_shards(mock_reconfigure, monkeypatch, b):
from bigchaindb.commands.bigchaindb import run_set_shards
# this will mock the call to retrieve the database config
# we will set it to return one replica
def mockreturn_one_replica(self, conn):
return {'shards': [{'replicas': [1]}]}
monkeypatch.setattr(rethinkdb.RqlQuery, 'run', mockreturn_one_replica)
args = Namespace(num_shards=3, config=None)
run_set_shards(args)
mock_reconfigure.assert_called_with(replicas=1, shards=3, dry_run=False)
# this will mock the call to retrieve the database config
# we will set it to return three replica
def mockreturn_three_replicas(self, conn):
return {'shards': [{'replicas': [1, 2, 3]}]}
monkeypatch.setattr(rethinkdb.RqlQuery, 'run', mockreturn_three_replicas)
run_set_shards(args)
mock_reconfigure.assert_called_with(replicas=3, shards=3, dry_run=False)
def test_set_shards_raises_exception(monkeypatch, b):
from bigchaindb.commands.bigchaindb import run_set_shards
# test that we are correctly catching the exception
def mock_raise(*args, **kwargs):
raise rethinkdb.ReqlOpFailedError('')
def mockreturn_one_replica(self, conn):
return {'shards': [{'replicas': [1]}]}
monkeypatch.setattr(rethinkdb.RqlQuery, 'run', mockreturn_one_replica)
monkeypatch.setattr(rethinkdb.ast.Table, 'reconfigure', mock_raise)
args = Namespace(num_shards=3, config=None)
with pytest.raises(SystemExit) as exc:
run_set_shards(args)
assert exc.value.args == ('Failed to reconfigure tables.',)
@patch('rethinkdb.ast.Table.reconfigure')
def test_set_replicas(mock_reconfigure, monkeypatch, b):
from bigchaindb.commands.bigchaindb import run_set_replicas
# this will mock the call to retrieve the database config
# we will set it to return two shards
def mockreturn_two_shards(self, conn):
return {'shards': [1, 2]}
monkeypatch.setattr(rethinkdb.RqlQuery, 'run', mockreturn_two_shards)
args = Namespace(num_replicas=2, config=None)
run_set_replicas(args)
mock_reconfigure.assert_called_with(replicas=2, shards=2, dry_run=False)
# this will mock the call to retrieve the database config
# we will set it to return three shards
def mockreturn_three_shards(self, conn):
return {'shards': [1, 2, 3]}
monkeypatch.setattr(rethinkdb.RqlQuery, 'run', mockreturn_three_shards)
run_set_replicas(args)
mock_reconfigure.assert_called_with(replicas=2, shards=3, dry_run=False)
def test_set_replicas_raises_exception(monkeypatch, b):
from bigchaindb.commands.bigchaindb import run_set_replicas
# test that we are correctly catching the exception
def mock_raise(*args, **kwargs):
raise rethinkdb.ReqlOpFailedError('')
def mockreturn_two_shards(self, conn):
return {'shards': [1, 2]}
monkeypatch.setattr(rethinkdb.RqlQuery, 'run', mockreturn_two_shards)
monkeypatch.setattr(rethinkdb.ast.Table, 'reconfigure', mock_raise)
args = Namespace(num_replicas=2, config=None)
with pytest.raises(SystemExit) as exc:
run_set_replicas(args)
assert exc.value.args == ('Failed to reconfigure tables.',)

241
tests/commands/test_commands.py
View File

@ -16,16 +16,12 @@ def test_make_sure_we_dont_remove_any_command():
assert parser.parse_args(['configure', 'localmongodb']).command assert parser.parse_args(['configure', 'localmongodb']).command
assert parser.parse_args(['configure', 'localmongodb']).command assert parser.parse_args(['configure', 'localmongodb']).command
assert parser.parse_args(['show-config']).command assert parser.parse_args(['show-config']).command
assert parser.parse_args(['export-my-pubkey']).command
assert parser.parse_args(['init']).command assert parser.parse_args(['init']).command
assert parser.parse_args(['drop']).command assert parser.parse_args(['drop']).command
assert parser.parse_args(['start']).command assert parser.parse_args(['start']).command
assert parser.parse_args(['set-shards', '1']).command
assert parser.parse_args(['set-replicas', '1']).command
assert parser.parse_args(['add-replicas', 'localhost:27017']).command
assert parser.parse_args(['remove-replicas', 'localhost:27017']).command
@pytest.mark.tendermint
@patch('bigchaindb.commands.utils.start') @patch('bigchaindb.commands.utils.start')
def test_main_entrypoint(mock_start): def test_main_entrypoint(mock_start):
from bigchaindb.commands.bigchaindb import main from bigchaindb.commands.bigchaindb import main
@ -40,12 +36,13 @@ def test_bigchain_run_start(mock_run_configure,
mocked_setup_logging): mocked_setup_logging):
from bigchaindb import config from bigchaindb import config
from bigchaindb.commands.bigchaindb import run_start from bigchaindb.commands.bigchaindb import run_start
args = Namespace(start_rethinkdb=False, allow_temp_keypair=False, config=None, yes=True, args = Namespace(config=None, yes=True,
skip_initialize_database=False) skip_initialize_database=False)
run_start(args) run_start(args)
mocked_setup_logging.assert_called_once_with(user_log_config=config['log']) mocked_setup_logging.assert_called_once_with(user_log_config=config['log'])
@pytest.mark.tendermint
@pytest.mark.skipif(reason="BigchainDB doesn't support the automatic creation of a config file anymore") @pytest.mark.skipif(reason="BigchainDB doesn't support the automatic creation of a config file anymore")
def test_bigchain_run_start_assume_yes_create_default_config( def test_bigchain_run_start_assume_yes_create_default_config(
monkeypatch, mock_processes_start, mock_generate_key_pair, monkeypatch, mock_processes_start, mock_generate_key_pair,
@ -63,7 +60,8 @@ def test_bigchain_run_start_assume_yes_create_default_config(
value['return'] = newconfig value['return'] = newconfig
monkeypatch.setattr(config_utils, 'write_config', mock_write_config) monkeypatch.setattr(config_utils, 'write_config', mock_write_config)
monkeypatch.setattr(config_utils, 'file_config', lambda x: config_utils.set_config(expected_config)) monkeypatch.setattr(config_utils, 'file_config',
lambda x: config_utils.set_config(expected_config))
monkeypatch.setattr('os.path.exists', lambda path: False) monkeypatch.setattr('os.path.exists', lambda path: False)
args = Namespace(config=None, yes=True) args = Namespace(config=None, yes=True)
@ -76,6 +74,7 @@ def test_bigchain_run_start_assume_yes_create_default_config(
# TODO Please beware, that if debugging, the "-s" switch for pytest will # TODO Please beware, that if debugging, the "-s" switch for pytest will
# interfere with capsys. # interfere with capsys.
# See related issue: https://github.com/pytest-dev/pytest/issues/128 # See related issue: https://github.com/pytest-dev/pytest/issues/128
@pytest.mark.tendermint
@pytest.mark.usefixtures('ignore_local_config_file') @pytest.mark.usefixtures('ignore_local_config_file')
def test_bigchain_show_config(capsys): def test_bigchain_show_config(capsys):
from bigchaindb import config from bigchaindb import config
@ -90,45 +89,7 @@ def test_bigchain_show_config(capsys):
assert output_config == config assert output_config == config
@pytest.mark.usefixtures('ignore_local_config_file') @pytest.mark.tendermint
def test_bigchain_export_my_pubkey_when_pubkey_set(capsys, monkeypatch):
from bigchaindb import config
from bigchaindb.commands.bigchaindb import run_export_my_pubkey
args = Namespace(config=None)
# so in run_export_my_pubkey(args) below,
# filename=args.config='dummy' is passed to autoconfigure().
# We just assume autoconfigure() works and sets
# config['keypair']['public'] correctly (tested elsewhere).
# We force-set config['keypair']['public'] using monkeypatch.
monkeypatch.setitem(config['keypair'], 'public', 'Charlie_Bucket')
_, _ = capsys.readouterr() # has the effect of clearing capsys
run_export_my_pubkey(args)
out, _ = capsys.readouterr()
lines = out.splitlines()
assert config['keypair']['public'] in lines
assert 'Charlie_Bucket' in lines
@pytest.mark.usefixtures('ignore_local_config_file')
def test_bigchain_export_my_pubkey_when_pubkey_not_set(monkeypatch):
from bigchaindb import config
from bigchaindb.commands.bigchaindb import run_export_my_pubkey
args = Namespace(config=None)
monkeypatch.setitem(config['keypair'], 'public', None)
# assert that run_export_my_pubkey(args) raises SystemExit:
with pytest.raises(SystemExit) as exc_info:
run_export_my_pubkey(args)
# exc_info is an object of class ExceptionInfo
# https://pytest.org/latest/builtin.html#_pytest._code.ExceptionInfo
assert exc_info.type == SystemExit
# exc_info.value is an object of class SystemExit
# https://docs.python.org/3/library/exceptions.html#SystemExit
assert exc_info.value.code == \
"This node's public key wasn't set anywhere so it can't be exported"
def test_bigchain_run_init_when_db_exists(mocker, capsys): def test_bigchain_run_init_when_db_exists(mocker, capsys):
from bigchaindb.commands.bigchaindb import run_init from bigchaindb.commands.bigchaindb import run_init
from bigchaindb.common.exceptions import DatabaseAlreadyExists from bigchaindb.common.exceptions import DatabaseAlreadyExists
@ -148,6 +109,7 @@ def test_bigchain_run_init_when_db_exists(mocker, capsys):
) )
@pytest.mark.tendermint
def test__run_init(mocker): def test__run_init(mocker):
from bigchaindb.commands.bigchaindb import _run_init from bigchaindb.commands.bigchaindb import _run_init
bigchain_mock = mocker.patch( bigchain_mock = mocker.patch(
@ -164,6 +126,7 @@ def test__run_init(mocker):
bigchain_mock.return_value.create_genesis_block.assert_called_once_with() bigchain_mock.return_value.create_genesis_block.assert_called_once_with()
@pytest.mark.tendermint
@patch('bigchaindb.backend.schema.drop_database') @patch('bigchaindb.backend.schema.drop_database')
def test_drop_db_when_assumed_yes(mock_db_drop): def test_drop_db_when_assumed_yes(mock_db_drop):
from bigchaindb.commands.bigchaindb import run_drop from bigchaindb.commands.bigchaindb import run_drop
@ -173,16 +136,19 @@ def test_drop_db_when_assumed_yes(mock_db_drop):
assert mock_db_drop.called assert mock_db_drop.called
@pytest.mark.tendermint
@patch('bigchaindb.backend.schema.drop_database') @patch('bigchaindb.backend.schema.drop_database')
def test_drop_db_when_interactive_yes(mock_db_drop, monkeypatch): def test_drop_db_when_interactive_yes(mock_db_drop, monkeypatch):
from bigchaindb.commands.bigchaindb import run_drop from bigchaindb.commands.bigchaindb import run_drop
args = Namespace(config=None, yes=False) args = Namespace(config=None, yes=False)
monkeypatch.setattr('bigchaindb.commands.bigchaindb.input_on_stderr', lambda x: 'y') monkeypatch.setattr(
'bigchaindb.commands.bigchaindb.input_on_stderr', lambda x: 'y')
run_drop(args) run_drop(args)
assert mock_db_drop.called assert mock_db_drop.called
@pytest.mark.tendermint
@patch('bigchaindb.backend.schema.drop_database') @patch('bigchaindb.backend.schema.drop_database')
def test_drop_db_when_db_does_not_exist(mock_db_drop, capsys): def test_drop_db_when_db_does_not_exist(mock_db_drop, capsys):
from bigchaindb import config from bigchaindb import config
@ -197,16 +163,19 @@ def test_drop_db_when_db_does_not_exist(mock_db_drop, capsys):
name=config['database']['name']) name=config['database']['name'])
@pytest.mark.tendermint
@patch('bigchaindb.backend.schema.drop_database') @patch('bigchaindb.backend.schema.drop_database')
def test_drop_db_does_not_drop_when_interactive_no(mock_db_drop, monkeypatch): def test_drop_db_does_not_drop_when_interactive_no(mock_db_drop, monkeypatch):
from bigchaindb.commands.bigchaindb import run_drop from bigchaindb.commands.bigchaindb import run_drop
args = Namespace(config=None, yes=False) args = Namespace(config=None, yes=False)
monkeypatch.setattr('bigchaindb.commands.bigchaindb.input_on_stderr', lambda x: 'n') monkeypatch.setattr(
'bigchaindb.commands.bigchaindb.input_on_stderr', lambda x: 'n')
run_drop(args) run_drop(args)
assert not mock_db_drop.called assert not mock_db_drop.called
@pytest.mark.tendermint
def test_run_configure_when_config_exists_and_skipping(monkeypatch): def test_run_configure_when_config_exists_and_skipping(monkeypatch):
from bigchaindb.commands.bigchaindb import run_configure from bigchaindb.commands.bigchaindb import run_configure
monkeypatch.setattr('os.path.exists', lambda path: True) monkeypatch.setattr('os.path.exists', lambda path: True)
@ -218,6 +187,7 @@ def test_run_configure_when_config_exists_and_skipping(monkeypatch):
# TODO Beware if you are putting breakpoints in there, and using the '-s' # TODO Beware if you are putting breakpoints in there, and using the '-s'
# switch with pytest. It will just hang. Seems related to the monkeypatching of # switch with pytest. It will just hang. Seems related to the monkeypatching of
# input_on_stderr. # input_on_stderr.
@pytest.mark.tendermint
def test_run_configure_when_config_does_not_exist(monkeypatch, def test_run_configure_when_config_does_not_exist(monkeypatch,
mock_write_config, mock_write_config,
mock_generate_key_pair, mock_generate_key_pair,
@ -230,6 +200,7 @@ def test_run_configure_when_config_does_not_exist(monkeypatch,
assert return_value is None assert return_value is None
@pytest.mark.tendermint
def test_run_configure_when_config_does_exist(monkeypatch, def test_run_configure_when_config_does_exist(monkeypatch,
mock_write_config, mock_write_config,
mock_generate_key_pair, mock_generate_key_pair,
@ -242,16 +213,17 @@ def test_run_configure_when_config_does_exist(monkeypatch,
from bigchaindb.commands.bigchaindb import run_configure from bigchaindb.commands.bigchaindb import run_configure
monkeypatch.setattr('os.path.exists', lambda path: True) monkeypatch.setattr('os.path.exists', lambda path: True)
monkeypatch.setattr('builtins.input', lambda: '\n') monkeypatch.setattr('builtins.input', lambda: '\n')
monkeypatch.setattr('bigchaindb.config_utils.write_config', mock_write_config) monkeypatch.setattr(
'bigchaindb.config_utils.write_config', mock_write_config)
args = Namespace(config='foo', yes=None) args = Namespace(config='foo', yes=None)
run_configure(args) run_configure(args)
assert value == {} assert value == {}
@pytest.mark.tendermint
@pytest.mark.parametrize('backend', ( @pytest.mark.parametrize('backend', (
'rethinkdb', 'localmongodb',
'mongodb',
)) ))
def test_run_configure_with_backend(backend, monkeypatch, mock_write_config): def test_run_configure_with_backend(backend, monkeypatch, mock_write_config):
import bigchaindb import bigchaindb
@ -279,54 +251,6 @@ def test_run_configure_with_backend(backend, monkeypatch, mock_write_config):
assert value['return'] == expected_config 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')
def test_allow_temp_keypair_generates_one_on_the_fly(
mock_gen_keypair, mock_processes_start,
mock_db_init_with_existing_db, mocked_setup_logging):
import bigchaindb
from bigchaindb.commands.bigchaindb import run_start
bigchaindb.config['keypair'] = {'private': None, 'public': None}
args = Namespace(allow_temp_keypair=True, start_rethinkdb=False, config=None, yes=True,
skip_initialize_database=False)
run_start(args)
mocked_setup_logging.assert_called_once_with(
user_log_config=bigchaindb.config['log'])
assert bigchaindb.config['keypair']['private'] == 'private_key'
assert bigchaindb.config['keypair']['public'] == 'public_key'
@patch('bigchaindb.common.crypto.generate_key_pair',
return_value=('private_key', 'public_key'))
@pytest.mark.usefixtures('ignore_local_config_file')
def test_allow_temp_keypair_doesnt_override_if_keypair_found(mock_gen_keypair,
mock_processes_start,
mock_db_init_with_existing_db,
mocked_setup_logging):
import bigchaindb
from bigchaindb.commands.bigchaindb import run_start
# Preconditions for the test
original_private_key = bigchaindb.config['keypair']['private']
original_public_key = bigchaindb.config['keypair']['public']
assert isinstance(original_public_key, str)
assert isinstance(original_private_key, str)
args = Namespace(allow_temp_keypair=True, start_rethinkdb=False, config=None, yes=True,
skip_initialize_database=False)
run_start(args)
mocked_setup_logging.assert_called_once_with(
user_log_config=bigchaindb.config['log'])
assert bigchaindb.config['keypair']['private'] == original_private_key
assert bigchaindb.config['keypair']['public'] == original_public_key
def test_run_start_when_db_already_exists(mocker, def test_run_start_when_db_already_exists(mocker,
monkeypatch, monkeypatch,
run_start_args, run_start_args,
@ -346,6 +270,7 @@ def test_run_start_when_db_already_exists(mocker,
assert mocked_start.called assert mocked_start.called
@pytest.mark.tendermint
def test_run_start_when_keypair_not_found(mocker, def test_run_start_when_keypair_not_found(mocker,
monkeypatch, monkeypatch,
run_start_args, run_start_args,
@ -371,33 +296,7 @@ def test_run_start_when_keypair_not_found(mocker,
assert not mocked_start.called assert not mocked_start.called
def test_run_start_when_start_rethinkdb_fails(mocker, @pytest.mark.tendermint
monkeypatch,
run_start_args,
mocked_setup_logging):
from bigchaindb import config
from bigchaindb.commands.bigchaindb import run_start
from bigchaindb.commands.messages import RETHINKDB_STARTUP_ERROR
from bigchaindb.common.exceptions import StartupError
run_start_args.start_rethinkdb = True
mocked_start = mocker.patch('bigchaindb.processes.start')
err_msg = 'Error starting rethinkdb.'
def mock_start_rethinkdb():
raise StartupError(err_msg)
monkeypatch.setattr(
'bigchaindb.commands.utils.start_rethinkdb', mock_start_rethinkdb)
with pytest.raises(SystemExit) as exc:
run_start(run_start_args)
mocked_setup_logging.assert_called_once_with(user_log_config=config['log'])
assert len(exc.value.args) == 1
assert exc.value.args[0] == RETHINKDB_STARTUP_ERROR.format(err_msg)
assert not mocked_start.called
@patch('argparse.ArgumentParser.parse_args') @patch('argparse.ArgumentParser.parse_args')
@patch('bigchaindb.commands.utils.base_parser') @patch('bigchaindb.commands.utils.base_parser')
@patch('bigchaindb.commands.utils.start') @patch('bigchaindb.commands.utils.start')
@ -424,102 +323,14 @@ def test_calling_main(start_mock, base_parser_mock, parse_args_mock,
subparsers.add_parser.assert_any_call('show-config', subparsers.add_parser.assert_any_call('show-config',
help='Show the current ' help='Show the current '
'configuration') 'configuration')
subparsers.add_parserassert_any_call('export-my-pubkey',
help="Export this node's public "
'key')
subparsers.add_parser.assert_any_call('init', help='Init the database') subparsers.add_parser.assert_any_call('init', help='Init the database')
subparsers.add_parser.assert_any_call('drop', help='Drop the database') subparsers.add_parser.assert_any_call('drop', help='Drop the database')
subparsers.add_parser.assert_any_call('start', help='Start BigchainDB') subparsers.add_parser.assert_any_call('start', help='Start BigchainDB')
subsubparsers.add_argument.assert_any_call('--dev-start-rethinkdb',
dest='start_rethinkdb',
action='store_true',
help='Run RethinkDB on start')
subsubparsers.add_argument.assert_any_call('--dev-allow-temp-keypair',
dest='allow_temp_keypair',
action='store_true',
help='Generate a random keypair on start')
subparsers.add_parser.assert_any_call('set-shards',
help='Configure number of shards')
subsubparsers.add_argument.assert_any_call('num_shards',
metavar='num_shards',
type=int, default=1,
help='Number of shards')
subparsers.add_parser.assert_any_call('set-replicas',
help='Configure number of replicas')
subsubparsers.add_argument.assert_any_call('num_replicas',
metavar='num_replicas',
type=int, default=1,
help='Number of replicas (i.e. '
'the replication factor)')
assert start_mock.called is True assert start_mock.called is True
@pytest.mark.usefixtures('ignore_local_config_file')
@patch('bigchaindb.commands.bigchaindb.add_replicas')
def test_run_add_replicas(mock_add_replicas):
from bigchaindb.commands.bigchaindb import run_add_replicas
from bigchaindb.backend.exceptions import OperationError
args = Namespace(config=None, replicas=['localhost:27017'])
# test add_replicas no raises
mock_add_replicas.return_value = None
assert run_add_replicas(args) is None
assert mock_add_replicas.call_count == 1
mock_add_replicas.reset_mock()
# test add_replicas with `OperationError`
mock_add_replicas.side_effect = OperationError('err')
with pytest.raises(SystemExit) as exc:
run_add_replicas(args)
assert exc.value.args == ('err',)
assert mock_add_replicas.call_count == 1
mock_add_replicas.reset_mock()
# test add_replicas with `NotImplementedError`
mock_add_replicas.side_effect = NotImplementedError('err')
with pytest.raises(SystemExit) as exc:
run_add_replicas(args)
assert exc.value.args == ('err',)
assert mock_add_replicas.call_count == 1
mock_add_replicas.reset_mock()
@pytest.mark.usefixtures('ignore_local_config_file')
@patch('bigchaindb.commands.bigchaindb.remove_replicas')
def test_run_remove_replicas(mock_remove_replicas):
from bigchaindb.commands.bigchaindb import run_remove_replicas
from bigchaindb.backend.exceptions import OperationError
args = Namespace(config=None, replicas=['localhost:27017'])
# test add_replicas no raises
mock_remove_replicas.return_value = None
assert run_remove_replicas(args) is None
assert mock_remove_replicas.call_count == 1
mock_remove_replicas.reset_mock()
# test add_replicas with `OperationError`
mock_remove_replicas.side_effect = OperationError('err')
with pytest.raises(SystemExit) as exc:
run_remove_replicas(args)
assert exc.value.args == ('err',)
assert mock_remove_replicas.call_count == 1
mock_remove_replicas.reset_mock()
# test add_replicas with `NotImplementedError`
mock_remove_replicas.side_effect = NotImplementedError('err')
with pytest.raises(SystemExit) as exc:
run_remove_replicas(args)
assert exc.value.args == ('err',)
assert mock_remove_replicas.call_count == 1
mock_remove_replicas.reset_mock()
@pytest.mark.tendermint @pytest.mark.tendermint
@pytest.mark.bdb @pytest.mark.bdb
def test_recover_db_from_zombie_txn(b, monkeypatch): def test_recover_db_from_zombie_txn(b, monkeypatch):
@ -597,7 +408,7 @@ def test_recover_db_on_start(mock_autoconfigure,
mock_start, mock_start,
mocked_setup_logging): mocked_setup_logging):
from bigchaindb.commands.bigchaindb import run_start from bigchaindb.commands.bigchaindb import run_start
args = Namespace(start_rethinkdb=False, allow_temp_keypair=False, config=None, yes=True, args = Namespace(config=None, yes=True,
skip_initialize_database=False) skip_initialize_database=False)
run_start(args) run_start(args)

21
tests/commands/test_utils.py
View File

@ -1,5 +1,5 @@
import argparse import argparse
from argparse import ArgumentTypeError, Namespace from argparse import Namespace
import logging import logging
import pytest import pytest
@ -119,20 +119,5 @@ def test_start_sets_multiprocess_var_based_on_cli_args(mock_cpu_count):
scope = {'run_mp_arg_test': run_mp_arg_test} scope = {'run_mp_arg_test': run_mp_arg_test}
assert utils.start(parser, ['mp_arg_test'], scope).multiprocess == 1 assert utils.start(parser, ['mp_arg_test'], scope).multiprocess == 1
assert utils.start(parser, ['mp_arg_test', '--multiprocess'], scope).multiprocess == 42 assert utils.start(
parser, ['mp_arg_test', '--multiprocess'], scope).multiprocess == 42
def test_mongodb_host_type():
from bigchaindb.commands.utils import mongodb_host
# bad port provided
with pytest.raises(ArgumentTypeError):
mongodb_host('localhost:11111111111')
# no port information provided
with pytest.raises(ArgumentTypeError):
mongodb_host('localhost')
# bad host provided
with pytest.raises(ArgumentTypeError):
mongodb_host(':27017')