def test_walletpassphrase_valid(self):
try:
log_json = ""
if xbridge_config.get_wallet_decryption_passphrase() == "":
return
valid_passphrase = xbridge_config.get_wallet_decryption_passphrase(
)
random_int = xbridge_utils.generate_random_int(
-999999999999, 999999999999)
self.assertIsNone(
xbridge_rpc.walletpassphrase(valid_passphrase, random_int,
False))
time_str = time.strftime("%Y%m%d-%H%M%S")
dumped_wallet_str = xbridge_config.get_conf_log_dir(
) + time_str + "_dumped_wallet.dat"
self.assertIsNone(
xbridge_utils.rpc_connection.dumpwallet(dumped_wallet_str))
self.assertIsNone(xbridge_rpc.walletlock())
xbridge_logger.XLOG("test_walletpassphrase_valid", 0)
except AssertionError as ass_err:
xbridge_logger.XLOG("test_walletpassphrase_valid", 1, ass_err,
[dumped_wallet_str])
except JSONRPCException as json_excpt:
xbridge_logger.XLOG("test_walletpassphrase_valid", 2, json_excpt,
[dumped_wallet_str])
def test_signmessage_invalid(self):
if xbridge_config.get_wallet_decryption_passphrase() == "":
return
valid_passphrase = xbridge_config.get_wallet_decryption_passphrase()
random_int = xbridge_utils.generate_random_int(-999999999999,
999999999999)
xbridge_rpc.walletpassphrase(valid_passphrase, random_int, False)
custom_set = [
x for x in xbridge_utils.set_of_invalid_parameters
if not isinstance(x, bool)
]
for i in range(subTest_count):
log_json = ""
with self.subTest("test_signmessage_invalid"):
try:
invalid_blocknet_address = random.choice(custom_set)
message = random.choice(custom_set)
self.assertRaises(
xbridge_custom_exceptions.ValidBlockNetException,
xbridge_rpc.signmessage, invalid_blocknet_address,
message)
log_json = {
"group": "test_signmessage_invalid",
"success": 1,
"failure": 0,
"error": 0
}
xbridge_utils.ERROR_LOG.append(log_json)
except AssertionError as ass_err:
log_json = {
"group": "test_signmessage_invalid",
"success": 0,
"failure": 1,
"error": 0
}
xbridge_utils.ERROR_LOG.append(log_json)
xbridge_logger.logger.info(
'test_signmessage_invalid FAILED: %s' % ass_err)
if MAX_LOG_LENGTH > 0:
xbridge_logger.logger.info(
'invalid_blocknet_address: %s \n' %
str(invalid_blocknet_address)[:MAX_LOG_LENGTH])
xbridge_logger.logger.info(
'param: %s \n' % str(message)[:MAX_LOG_LENGTH])
except JSONRPCException as json_excpt:
log_json = {
"group": "test_signmessage_invalid",
"success": 0,
"failure": 0,
"error": 1
}
xbridge_utils.ERROR_LOG.append(log_json)
xbridge_logger.logger.info(
'test_signmessage_invalid ERROR: %s' % json_excpt)
if MAX_LOG_LENGTH > 0:
xbridge_logger.logger.info(
'invalid_blocknet_address: %s \n' %
str(invalid_blocknet_address)[:MAX_LOG_LENGTH])
xbridge_logger.logger.info(
'param: %s \n' % str(message)[:MAX_LOG_LENGTH])
def test_getaddednodeinfo_invalid(self):
log_json = ""
if xbridge_config.get_wallet_decryption_passphrase() == "":
return
valid_passphrase = xbridge_config.get_wallet_decryption_passphrase()
random_int = xbridge_utils.generate_random_int(-999999999999, 999999999999)
xbridge_rpc.walletpassphrase(valid_passphrase, random_int, False)
self.assertIsInstance(xbridge_rpc.rpc_connection.getaddednodeinfo(True), list)
self.assertIsInstance(xbridge_rpc.rpc_connection.getaddednodeinfo(False), list)
for i in range(subTest_count):
log_json = ""
with self.subTest("comb"):
try:
dns = random.choice(xbridge_utils.set_of_invalid_parameters)
node = random.choice(xbridge_utils.set_of_invalid_parameters)
self.assertRaises(xbridge_custom_exceptions.ValidBlockNetException, xbridge_rpc.getaddednodeinfo, dns, node)
log_json = {"group": "test_getaddednodeinfo_invalid", "success": 1, "failure": 0, "error": 0}
xbridge_utils.ERROR_LOG.append(log_json)
except AssertionError as ass_err:
log_json = {"group": "test_getaddednodeinfo_invalid", "success": 0, "failure": 1, "error": 0}
xbridge_utils.ERROR_LOG.append(log_json)
xbridge_logger.logger.info('test_getaddednodeinfo_invalid FAILED: %s' % ass_err)
if MAX_LOG_LENGTH > 0:
xbridge_logger.logger.info('dns: %s' % str(dns)[:MAX_LOG_LENGTH])
xbridge_logger.logger.info('node: %s' % str(dns)[:MAX_LOG_LENGTH])
except JSONRPCException as json_excpt:
xbridge_logger.logger.info('test_getaddednodeinfo_invalid ERROR: %s' % str(json_excpt))
log_json = {"group": "test_getaddednodeinfo_invalid", "success": 0, "failure": 0, "error": 1}
xbridge_utils.ERROR_LOG.append(log_json)
if MAX_LOG_LENGTH > 0:
xbridge_logger.logger.info('dns: %s' % str(dns)[:MAX_LOG_LENGTH])
xbridge_logger.logger.info('node: %s' % str(dns)[:MAX_LOG_LENGTH])
def test_addnode_invalid(self):
if xbridge_config.get_wallet_decryption_passphrase() == "":
return
valid_passphrase = xbridge_config.get_wallet_decryption_passphrase()
random_int = xbridge_utils.generate_random_int(1, 9999)
for i in range(subTest_count):
log_json = ""
with self.subTest("comb"):
try:
node = random.choice(xbridge_utils.set_of_invalid_parameters)
cmd = random.choice(xbridge_utils.set_of_invalid_parameters)
xbridge_rpc.walletpassphrase(valid_passphrase, random_int, False)
self.assertRaises(xbridge_custom_exceptions.ValidBlockNetException, xbridge_rpc.addnode, node, cmd)
log_json = {"group": "test_addnode_invalid", "success": 1, "failure": 0, "error": 0}
xbridge_utils.ERROR_LOG.append(log_json)
except AssertionError as ass_err:
log_json = {"group": "test_addnode_invalid", "success": 0, "failure": 1, "error": 0}
xbridge_utils.ERROR_LOG.append(log_json)
xbridge_logger.logger.info('test_addnode_invalid FAILED: %s' % ass_err)
if MAX_LOG_LENGTH > 0:
xbridge_logger.logger.info('node: %s' % str(node)[:MAX_LOG_LENGTH])
xbridge_logger.logger.info('cmd: %s' % str(cmd)[:MAX_LOG_LENGTH])
except JSONRPCException as json_excpt:
xbridge_logger.logger.info('test_addnode_invalid ERROR: %s' % str(json_excpt))
log_json = {"group": "test_addnode_invalid", "success": 0, "failure": 0, "error": 1}
xbridge_utils.ERROR_LOG.append(log_json)
if MAX_LOG_LENGTH > 0:
xbridge_logger.logger.info('node: %s' % str(node)[:MAX_LOG_LENGTH])
xbridge_logger.logger.info('cmd: %s' % str(cmd)[:MAX_LOG_LENGTH])
def test_backupwallet_invalid(self):
if xbridge_config.get_wallet_decryption_passphrase() == "":
return
# print("wallet passphrase: " + xbridge_config.get_wallet_decryption_passphrase())
valid_passphrase = xbridge_config.get_wallet_decryption_passphrase()
random_int = xbridge_utils.generate_random_int(-999999999999, 999999999999)
random_bool = random.choice([True, False])
self.assertIsNone(xbridge_rpc.walletpassphrase(valid_passphrase, random_int, False))
for basic_garbage_str in xbridge_utils.set_of_invalid_parameters:
with self.subTest(basic_garbage_str=basic_garbage_str):
try:
self.assertIsNone(xbridge_rpc.rpc_connection.backupwallet, basic_garbage_str)
xbridge_logger.XLOG("test_backupwallet_invalid", 0)
except AssertionError as ass_err:
xbridge_logger.XLOG("test_backupwallet_invalid", 1, ass_err, [basic_garbage_str])
except JSONRPCException as json_excpt:
xbridge_logger.XLOG("test_backupwallet_invalid", 2, json_excpt, [basic_garbage_str])
def test_walletpassphrasechange_valid(self):
try:
if xbridge_config.get_wallet_decryption_passphrase() == "":
return
current_valid_passphrase = xbridge_config.get_wallet_decryption_passphrase(
)
random_valid_new_passphrase = xbridge_utils.generate_random_valid_passphrase(
)
xbridge_rpc.walletpassphrasechange(current_valid_passphrase,
random_valid_new_passphrase)
xbridge_logger.XLOG("test_walletpassphrasechange_valid", 0)
self.assertIsNone(
xbridge_rpc.walletpassphrasechange(random_valid_new_passphrase,
current_valid_passphrase))
xbridge_logger.XLOG("test_walletpassphrasechange_valid", 0)
except AssertionError as ass_err:
xbridge_logger.XLOG(
"test_walletpassphrasechange_valid", 1, ass_err,
[current_valid_passphrase, random_valid_new_passphrase])
except JSONRPCException as json_excpt:
xbridge_logger.XLOG(
"test_walletpassphrasechange_valid", 2, json_excpt,
[current_valid_passphrase, random_valid_new_passphrase])
def test_autocombinerewards_valid(self):
try:
if xbridge_config.get_wallet_decryption_passphrase() == "":
return
valid_passphrase = xbridge_config.get_wallet_decryption_passphrase(
)
random_int = xbridge_utils.generate_random_int(
-999999999999, 999999999999)
xbridge_rpc.walletpassphrase(valid_passphrase, random_int, False)
log_json = ""
success_str = "Auto Combine Rewards Threshold Set"
xbridge_utils.generate_new_set_of_data(
data_nature=xbridge_utils.VALID_DATA)
self.assertEqual(
xbridge_rpc.rpc_connection.autocombinerewards(False),
success_str)
self.assertEqual(
xbridge_rpc.rpc_connection.autocombinerewards(
False, -99999999999999), success_str)
self.assertEqual(
xbridge_rpc.rpc_connection.autocombinerewards(True, 0),
success_str)
self.assertEqual(
xbridge_rpc.rpc_connection.autocombinerewards(
True, xbridge_utils.valid_random_positive_int),
success_str)
self.assertEqual(
xbridge_rpc.rpc_connection.autocombinerewards(
True, -xbridge_utils.valid_random_positive_int),
success_str)
log_json = {
"group": "test_autocombinerewards_valid",
"success": 1,
"failure": 0,
"error": 0
}
xbridge_utils.ERROR_LOG.append(log_json)
except AssertionError as ass_err:
log_json = {
"group": "test_autocombinerewards_valid",
"success": 0,
"failure": 1,
"error": 0
}
xbridge_utils.ERROR_LOG.append(log_json)
xbridge_logger.logger.info(
'test_autocombinerewards_valid FAILED: %s' % ass_err)
if MAX_LOG_LENGTH > 0:
xbridge_logger.logger.info(
'fixed_positive_int: %s \n' %
str(xbridge_utils.fixed_positive_int))
xbridge_logger.logger.info(
'fixed_negative_int: %s \n' %
str(xbridge_utils.fixed_negative_int))
xbridge_logger.logger.info(
'valid_random_positive_int: %s \n' %
str(xbridge_utils.valid_random_positive_int))
except JSONRPCException as json_excpt:
log_json = {
"group": "test_autocombinerewards_valid",
"success": 0,
"failure": 0,
"error": 1
}
xbridge_utils.ERROR_LOG.append(log_json)
xbridge_logger.logger.info(
'test_autocombinerewards_valid ERROR: %s' % json_excpt)