def check_outputs(tx_name, method, inputs, outputs, error, records, server_db):
"""Check actual and expected outputs of a particular function."""
try:
tested_module = sys.modules['shellpartylib.lib.{}'.format(tx_name)]
except KeyError: # TODO: hack
tested_module = sys.modules['shellpartylib.lib.messages.{}'.format(tx_name)]
tested_method = getattr(tested_module, method)
test_outputs = None
if error is not None:
with pytest.raises(error[0]) as exception:
test_outputs = exec_tested_method(tx_name, method, tested_method, inputs, server_db)
else:
test_outputs = exec_tested_method(tx_name, method, tested_method, inputs, server_db)
if pytest.config.option.gentxhex and method == 'compose':
print('')
tx_params = {
'encoding': 'multisig'
}
if tx_name == 'order' and inputs[1]=='SCH':
print('give shell')
tx_params['fee_provided'] = DP['fee_provided']
unsigned_tx_hex = transaction.construct(server_db, test_outputs, **tx_params)
print(tx_name)
print(unsigned_tx_hex)
if outputs is not None:
assert outputs == test_outputs
if error is not None:
assert str(exception.value) == error[1]
if records is not None:
for record in records:
check_record(record, server_db)
def compose_transaction(db, name, params,
encoding='auto',
fee_per_kb=config.DEFAULT_FEE_PER_KB,
regular_dust_size=config.DEFAULT_REGULAR_DUST_SIZE,
multisig_dust_size=config.DEFAULT_MULTISIG_DUST_SIZE,
op_return_value=config.DEFAULT_OP_RETURN_VALUE,
pubkey=None,
allow_unconfirmed_inputs=False,
fee=None,
fee_provided=0):
"""Create and return a transaction."""
# Get provided pubkeys.
if type(pubkey) == str:
provided_pubkeys = [pubkey]
elif type(pubkey) == list:
provided_pubkeys = pubkey
elif pubkey == None:
provided_pubkeys = []
else:
assert False
# Get additional pubkeys from `source` and `destination` params.
# Convert `source` and `destination` to pubkeyhash form.
for address_name in ['source', 'destination']:
if address_name in params:
address = params[address_name]
provided_pubkeys += script.extract_pubkeys(address)
params[address_name] = script.make_pubkeyhash(address)
# Check validity of collected pubkeys.
for pubkey in provided_pubkeys:
if not script.is_fully_valid(binascii.unhexlify(pubkey)):
raise script.AddressError('invalid public key: {}'.format(pubkey))
compose_method = sys.modules['shellpartylib.lib.messages.{}'.format(name)].compose
compose_params = inspect.getargspec(compose_method)[0]
missing_params = [p for p in compose_params if p not in params and p != 'db']
for param in missing_params:
params[param] = None
# try: # NOTE: For debugging, e.g. with `Invalid Params` error.
tx_info = compose_method(db, **params)
return transaction.construct(db, tx_info, encoding=encoding,
fee_per_kb=fee_per_kb,
regular_dust_size=regular_dust_size,
multisig_dust_size=multisig_dust_size,
op_return_value=op_return_value,
provided_pubkeys=provided_pubkeys,
allow_unconfirmed_inputs=allow_unconfirmed_inputs,
exact_fee=fee,
fee_provided=fee_provided)
def run_scenario(scenario, rawtransactions_db):
"""Execute a scenario for integration test, returns a dump of the db, a json with raw transactions and the full log."""
server.initialise(database_file=':memory:', testnet=True, **SCHPARTYD_OPTIONS)
config.PREFIX = b'TESTXXXX'
util.FIRST_MULTISIG_BLOCK_TESTNET = 1
checkpoints = dict(check.CHECKPOINTS_TESTNET)
check.CHECKPOINTS_TESTNET = {}
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
logger_buff = io.StringIO()
handler = logging.StreamHandler(logger_buff)
handler.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
requests_log = logging.getLogger("requests")
requests_log.setLevel(logging.WARNING)
asyncio_log = logging.getLogger('asyncio')
asyncio_log.setLevel(logging.ERROR)
db = database.get_connection(read_only=False)
initialise_db(db)
raw_transactions = []
for tx in scenario:
if tx[0] != 'create_next_block':
module = sys.modules['shellpartylib.lib.messages.{}'.format(tx[0])]
compose = getattr(module, 'compose')
unsigned_tx_hex = transaction.construct(db, compose(db, *tx[1]), **tx[2])
raw_transactions.append({tx[0]: unsigned_tx_hex})
insert_raw_transaction(unsigned_tx_hex, db, rawtransactions_db)
else:
create_next_block(db, block_index=config.BURN_START + tx[1], parse_block=True)
dump = dump_database(db)
log = logger_buff.getvalue()
db.close()
check.CHECKPOINTS_TESTNET = checkpoints
return dump, log, json.dumps(raw_transactions, indent=4)