def test_no_config_file_exists():
"""Test that a new `two1.json` file is created if it doesn't exist."""
mock_config = mock.mock_open()
mock_config.side_effect = [FileNotFoundError(), mock.DEFAULT]
with mock.patch('two1.commands.util.config.Config.save',
return_value=None):
with mock.patch('two1.commands.util.config.open',
mock_config,
create=True):
config.Config('config_file')
assert mock_config.call_count == 2
dc = json.loads(mock_config.return_value.write.call_args[0][0])
mock_config.assert_called_with('config_file', mode='w')
assert dc['username'] is None
assert dc['sellprice'] == 10000
assert dc['contact'] == "*****@*****.**"
assert dc['stdout'] == ".two1/two1.stdout"
assert dc['stderr'] == ".two1/two1.stderr"
assert dc['sortby'] == "price"
assert dc['maxspend'] == 20000
assert dc['verbose'] is False
assert dc['mining_auth_pubkey'] is None
assert dc['auto_update'] is False
assert dc['wallet_path'] == wallet.Two1Wallet.DEFAULT_WALLET_PATH
assert dc['collect_analytics'] is True
def __init__(self, wallet):
"""Initialize the on-chain request with a wallet."""
super().__init__()
self.wallet = wallet
try:
self.username = config.Config().username
except exceptions.FileDecodeError:
self.username = None
def __init__(self):
"""
Constructor for the Rev class.
"""
self.config = two1_config.Config(two1.TWO1_CONFIG_FILE, None)
self.wallet = wallet_utils.get_or_create_wallet(self.config.wallet_path)
self.machine_auth = machine_auth_wallet.MachineAuthWallet(self.wallet)
self.client = rest_client.TwentyOneRestClient(two1.TWO1_HOST, self.machine_auth, self.config.username)
def create_default_rest_client():
"""Return a rest client using default parameters."""
import two1
from two1 import wallet
from two1.commands.util import config
from two1.server import machine_auth_wallet, rest_client
auth = machine_auth_wallet.MachineAuthWallet(wallet.Wallet())
return rest_client.TwentyOneRestClient(two1.TWO1_HOST, auth,
config.Config().username)
def test_invalid_config_file():
"""Test that an invalid `two1.json` file cannot be imported."""
mock_config = mock.mock_open(mock=mock.Mock(side_effect=ValueError))
with mock.patch('two1.commands.util.config.open', mock_config,
create=True), pytest.raises(
exceptions.FileDecodeError): # nopep8
config.Config('config_file')
mock_config.assert_called_with('config_file', mode='r')
def __init__(self, wallet, deposit_amount=DEFAULT_DEPOSIT_AMOUNT, duration=DEFAULT_DURATION):
"""Initialize the channel requests with a payment channel client."""
super().__init__()
self._channelclient = ChannelRequests.channels.PaymentChannelClient(wallet)
self._deposit_amount = deposit_amount
self._duration = duration
try:
self.username = config.Config().username
except exceptions.FileDecodeError:
self.username = None
def test_needs_old_last_update_check_with_new_version():
"""Test for a last_update_check more than 3600 seconds ago, but version is new
and that it does not suggest an update"""
mock_config = mock.mock_open(read_data=CONFIG_DATA)
with mock.patch('two1.commands.util.config.open', mock_config,
create=True):
c = config.Config('config_file')
c.set('last_update_check', 000000.000, should_save=True)
with capture_stdout(config.Config, 'config_file') as output:
assert len(output.strip()) == 0
def parse_config(
config_file=two1.TWO1_CONFIG_FILE,
config_dict=None,
need_wallet_and_account=True,
check_update=False,
debug=False,
):
"""Get configuration information that is used to drive all 21 commands.
This function is very useful for testing as it builds up several
key variables (like the client, wallet, username, and the like)
that are used in many commands. The way it does this is by taking
in the config_file (typically .two1/two1.json) and the config_dict
(a list of key-value pairs to override the config_file, typically
an empty dictionary), and then running the logic below.
It returns obj which is a dictionary that has Config, Wallet,
MachineAuth, and TwentyOneRestClient instances underneath it, as
well as a string with the username. The obj is passed down by
click to various other commands.
You can use this function in any test to instantiate the user's
wallet, username, and other variables.
"""
try:
config = two1_config.Config(config_file,
config_dict,
check_update=check_update)
except exceptions.FileDecodeError as e:
raise click.ClickException(
uxstring.UxString.Error.file_decode.format((str(e))))
wallet, machine_auth, username, client = None, None, None, None
if need_wallet_and_account:
try:
wallet = wallet_utils.get_or_create_wallet(config.wallet_path)
except blockchain_exceptions.DataProviderError as err:
raise exceptions.Two1Error(
'You have experienced a data provider error: %s ' % err.args)
machine_auth = machine_auth_wallet.MachineAuthWallet(wallet)
username = account_utils.get_or_create_username(config, machine_auth)
client = rest_client.TwentyOneRestClient(two1.TWO1_HOST, machine_auth,
config.username)
config.username = username
obj = dict(
config=config,
wallet=wallet,
machine_auth=machine_auth,
username=username,
client=client,
debug=debug,
)
return obj
def __init__(self, wallet, username=None):
"""Initialize the bittransfer with wallet and username."""
from two1.server.machine_auth_wallet import MachineAuthWallet
super().__init__()
if isinstance(wallet, MachineAuthWallet):
self.wallet = wallet
else:
self.wallet = MachineAuthWallet(wallet)
if username is None:
self.username = config.Config().username
else:
self.username = username
def test_last_update_check_set():
"""Asert last_update_check is set in a config with none."""
mock_config = mock.mock_open(read_data=CONFIG_DATA)
assert 'last_update_check' not in CONFIG_DATA
with mock.patch('two1.commands.util.config.open', mock_config,
create=True):
conf = config.Config('config_file')
# last_update_check should now be set after
# initalizing the config object.
assert hasattr(conf, 'last_update_check')
assert 'last_update_check' in json.loads(
mock_config.return_value.write.call_args[0][0])
def test_needs_update_legacy_last_update_check():
"""Test for a legacy two1.json with an older last_update_check, and that
it does not throw an error"""
mock_config = mock.mock_open(read_data=CONFIG_DATA)
with mock.patch('two1.commands.util.config.open', mock_config,
create=True):
c = config.Config('config_file')
c.set('last_update_check', "", should_save=True)
try:
c.check_update()
except ValueError:
pytest.fail("Error dealing with legacy timestamp")
def test_default_config():
"""Test Config object loads defualt settings when file is incomplete."""
c = config.Config('config_file')
assert c.username is None
assert c.sellprice == 10000
assert c.contact == "*****@*****.**"
assert c.stdout == ".two1/two1.stdout"
assert c.stderr == ".two1/two1.stderr"
assert c.sortby == "price"
assert c.maxspend == 20000
assert c.verbose is False
assert c.mining_auth_pubkey is None
assert c.auto_update is False
assert c.wallet_path == wallet.Two1Wallet.DEFAULT_WALLET_PATH
assert c.collect_analytics is True
def test_basic_config():
"""Test Config object can load a file and access its settings."""
c = config.Config('config_file')
assert c.username == 'satoshi'
assert c.sellprice == 11000
assert c.contact == '*****@*****.**'
assert c.stdout == '.two1/two1.stdout'
assert c.stderr == '.two1/two1.stderr'
assert c.sortby == 'price'
assert c.maxspend == 25000
assert c.verbose is False
assert c.mining_auth_pubkey == 'i_haz_key'
assert c.auto_update is False
assert c.wallet_path == wallet.Two1Wallet.DEFAULT_WALLET_PATH
assert c.collect_analytics is True
def test_config_repr():
"""Test Config object can be displayed nicely in `print` statements."""
c = config.Config('config_file')
printed = c.__repr__()
assert 'satoshi' in printed
assert '11000' in printed
assert '*****@*****.**' in printed
assert '.two1/two1.stdout' in printed
assert '.two1/two1.stderr' in printed
assert 'price' in printed
assert '25000' in printed
assert 'False' in printed
assert 'i_haz_key' in printed
assert 'False' in printed
assert wallet.Two1Wallet.DEFAULT_WALLET_PATH in printed
assert 'True' in printed
def __init__(self, wallet, username=None, client=None):
"""Initialize the bittransfer with wallet and username."""
from two1.server.machine_auth_wallet import MachineAuthWallet
from two1.server import rest_client
super().__init__()
if isinstance(wallet, MachineAuthWallet):
self.wallet = wallet
else:
self.wallet = MachineAuthWallet(wallet)
if username is None:
self.username = config.Config().username
else:
self.username = username
if client is None:
self.client = rest_client.TwentyOneRestClient(
two1.TWO1_HOST, self.wallet, self.username)
else:
self.client = client
def test_save_config():
"""Test Config object can save to update a file."""
mock_config = mock.mock_open(read_data=CONFIG_DATA)
with mock.patch('two1.commands.util.config.open', mock_config,
create=True):
c = config.Config('config_file')
num_config_keys = len(c.state.keys())
# Update an existing key and add a new one
with mock.patch('two1.commands.util.config.open', mock_config,
create=True):
c.set('username', 'TEST_USERNAME', should_save=True)
c.set('some_list_key', [123, 456, 789], should_save=True)
# Import the newly saved configuration file
new_config = json.loads(mock_config.return_value.write.call_args[0][0])
mock_config.assert_called_with('config_file', mode='w')
assert c.username == 'TEST_USERNAME'
assert c.some_list_key == [123, 456, 789]
assert new_config['username'] == 'TEST_USERNAME'
assert new_config['some_list_key'] == [123, 456, 789]
assert len(new_config.keys()) == num_config_keys + 1
import logging
import os
from transcodeE16 import TranscodeE16
from two1.commands.util import config
from two1.wallet import Wallet
from two1.bitrequests import BitTransferRequests
requests = BitTransferRequests(Wallet(), config.Config().username)
log = logging.getLogger('werkzeug')
log.setLevel(logging.INFO)
def testDuration():
"""
Tests getting the duration for a sample video.
"""
try:
log.warning("In testDuration()")
dataDir = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'data')
# Create the speed testing client
transcoder = TranscodeE16(dataDir)
duration = transcoder.getDuration('http://www.esixteen.co/video/sample.mp4')
log.info("Success!")
log.info("Duration test completed with duration: {}", duration)
except Exception as err:
log.warning('Client test failed')
return {'Bitcoin-Transaction': 'paid'}
def mockrequest(*args, **kwargs):
mock_request = MockRequest()
mock_headers = {'price': '1337', 'bitcoin-address': '1THISISANADDRESS'}
setattr(mock_request, 'status_code', 402)
setattr(mock_request, 'headers', mock_headers)
setattr(mock_request, 'response_method', args[0])
return mock_request
##############################################################################
# Set up Two1 command line config
config = config.Config()
# Inject the mock wallet into config as a test dependency
wallet = MockWallet()
# Mock two1 rest client
client = MockTwentyOneRestClient()
def test_onchain_request():
"""Test that it handles on-chain requests."""
bit_req = OnChainRequests(wallet)
test_max_price = 10000
price = 1000
address = 'test_bitserv_host_address'
mock_request = MockRequest()
headers = {'price': price, 'bitcoin-address': address}
setattr(mock_request, 'headers', headers)
data = {"public_key": public_key}
data_json = json.dumps(data)
path = "/pool/account/{}/wallets/primary/".format(self.username)
resp = self._request(sign_username=self.username,
method="POST",
path=path,
data=data_json)
return resp.json()
def list_wallets(self):
path = "/pool/account/{}/wallets/".format(self.username)
resp = self._request(sign_username=self.username,
method="GET",
path=path)
return resp.json()
if __name__ == "__main__":
# host = "http://127.0.0.1:8000"
from two1.commands.util import config
conf = config.Config()
host = two1.TWO1_HOST
for n in range(2):
m = TwentyOneRestClient(host, conf.machine_auth, conf.username)
try:
earn = m.get_mined_satoshis()
except requests.exceptions.ConnectionError:
print("Error: cannot connect to ", host)
def main(ctx, wallet_path, passphrase, blockchain_data_provider, insight_url,
insight_api_path, debug):
""" Command-line Interface for the Two1 Wallet
"""
if wallet_path is None:
try:
config = two1_config.Config(config_file)
wallet_path = config.wallet_path
except two1exceptions.FileDecodeError as e:
raise click.ClickException(
uxstring.UxString.Error.file_decode.format((str(e))))
wp = Path(wallet_path)
# Initialize some logging handlers
ch = logging.StreamHandler()
ch_formatter = logging.Formatter('%(levelname)s: %(message)s')
ch.setFormatter(ch_formatter)
if not os.path.exists(wp.dirname()):
os.makedirs(wp.dirname())
fh = logging.handlers.TimedRotatingFileHandler(
wp.dirname().joinpath("wallet_cli.log"),
when='midnight',
backupCount=5)
fh_formatter = logging.Formatter('%(asctime)s %(levelname)s: %(message)s')
fh.setFormatter(fh_formatter)
logger.addHandler(ch)
logger.addHandler(fh)
fh.setLevel(logging.DEBUG if debug else logging.INFO)
ch.setLevel(logging.DEBUG if debug else logging.WARNING)
logger.setLevel(logging.DEBUG if debug else logging.INFO)
logger.info("Wallet client started.")
if ctx.obj is None:
ctx.obj = {}
ctx.obj['wallet_path'] = wallet_path
ctx.obj['passphrase'] = passphrase
if ctx.invoked_subcommand not in ['create', 'restore']:
# Check that the wallet path exists
if not Two1Wallet.check_wallet_file(ctx.obj['wallet_path']):
click.echo("ERROR: Wallet file does not exist or is corrupt.")
ctx.exit(code=7)
p = get_passphrase() if passphrase else ''
try:
logger.info("Loading wallet %s ..." % (wp))
ctx.obj['wallet'] = Wallet(wallet_path=wallet_path,
data_provider=ctx.obj['data_provider'],
passphrase=p)
logger.info("... loading complete.")
except exceptions.PassphraseError as e:
click.echo(str(e))
ctx.exit(code=1)
except (TypeError, ValueError) as e:
logger.error("Internal wallet error. Please report this as a bug.")
logger.debug("".join(traceback.format_tb(e.__traceback__)))
ctx.exit(code=2)
def _on_close():
try:
ctx.obj['wallet'].sync_wallet_file()
except:
pass
ctx.call_on_close(_on_close)
