def wait_tx_result(self, txhash):
for i in range(Config.GEN_BLOCK_TIMEOUT):
time.sleep(1)
(ret, response) = RPC_API.getsmartcodeevent(tx_hash=txhash,
process_log=False)
if ret:
try:
logger.info("tx hash:" + str(txhash) + " " +
json.dumps(response))
state = response["result"]["State"]
if state == 1:
logger.info("tx hash:" + str(txhash) + " state = 1")
return True
else:
return False
except Exception as e:
logger.print(
"tx hash:" + str(txhash) +
" no tx state info, may be block not generate yet...")
continue
else:
logger.error("tx hash:" + str(txhash) +
" getsmartcodeevent error")
return False
logger.error("tx hash:" + str(txhash) + " state timeout!")
return False
def sftp_transfer_dir(_from, _to, _node_index, _op="get"):
# on local host
if _node_index == 0:
cmd = "cp -rf " + _from + " " + _to
os.system(cmd)
return
private_key = paramiko.RSAKey.from_private_key_file(
"../../resource/id_rsa", "367wxd")
transport = paramiko.Transport((Config.NODES[_node_index]["ip"], 22))
transport.connect(username="******", pkey=private_key)
sftp = paramiko.SFTPClient.from_transport(transport)
try:
sftp.mkdir(_to)
except:
pass
for item in os.listdir(_from):
if _op == "put":
sftp.put(os.path.join(_from, item), os.path.join(_to, item))
elif _op == "get":
sftp.get(os.path.join(_from, item), os.path.join(_to, item))
else:
logger.error("operation not supported")
transport.close()
def test_22(self):
try:
API.node().sftp_transfer("SFTPTEST.txt", Config.NODES[0]["path"].replace("neo-cli.dll", ""), 0)
'''
API.clirpc(0).terminate()
API.clirpc(1).terminate()
API.clirpc(2).terminate()
API.clirpc(3).terminate()
return
API.node().clear_block()
API.node(1).clear_block()
API.node(2).clear_block()
API.node(3).clear_block()
API.clirpc(0).init("clirpc0", Config.NODES[0]["path"])
API.clirpc(0).exec(False)
API.clirpc(1).init("clirpc1", Config.NODES[1]["path"])
API.clirpc(1).exec(False)
API.clirpc(2).init("clirpc2", Config.NODES[2]["path"])
API.clirpc(2).exec(False)
API.clirpc(3).init("clirpc3", Config.NODES[3]["path"])
API.clirpc(3).exec(False)
'''
except AssertError as e:
logger.error(e.msg)
except Exception as e:
logger.error(traceback.format_exc())
def test_base_001_benefit(self):
process = False
try:
address1 = Config.NODES[1]["address"]
(process, response) = API.rpc().getbalance(address1)
self.BLOCK(process, "get balance error")
ong1 = int(response["result"]["ong"])
(process, response) = API.native().transfer_ont(
Config.NODES[0]["address"],
Config.NODES[0]["address"],
"1",
gas_price=test_config.PRICE_TEST)
#判断是否分润，至少需要等待1个共识时间
(process, response) = API.native().commit_dpos(sleep=0)
self.BLOCK(process, "can't gen block")
API.node().wait_gen_block()
(process, response) = API.rpc().getbalance(address1)
self.BLOCK(process, "get balance error")
ong2 = int(response["result"]["ong"])
logger.info("before cost[1]: " + str(ong1))
logger.info("after cost[1]: " + str(ong2))
self.ASSERT(ong2 != ong1, "get balance error")
except Exception as e:
logger.error(e.args[0])
def __init__(self, code):
self.code = code
self.msg = "UNKNOW ERROR"
if code in Config.ERR_CODE:
self.msg = Config.ERR_CODE[code]
logger.error(self.msg)
def con_restful(ip, api_request):
try:
url = ""
if ip:
url = "http://" + ip + ":20334"
else:
url = Config.RESTFUL_URL
api_url = url + api_request["api"]
api_command = "GET"
if "command" in api_request:
api_command = api_request["command"]
if api_command == "POST":
api_post_data = None
if "params" in api_request:
api_post_data = api_request["params"]
api_post_data_encode = json.dumps(api_post_data)
api_post_data_encode = bytes(api_post_data_encode, 'utf8')
req = urllib.request.Request(url=api_url,
data=api_post_data_encode)
response = urllib.request.urlopen(req)
return json.loads(response.read().decode("utf-8"))
else:
response = urllib.request.urlopen(api_url)
return json.loads(response.read().decode("utf-8"))
except Exception as e:
logger.error("con_restful:" + str(e.args[0]))
raise TestError(54002)
def test_02_getaccountstate(self):
try:
result = API.rpc().getaccountstate(
Config.NODES[0]["wallet"].account().address())
self.ASSERT(result, "")
except Exception as e:
logger.error(traceback.format_exc())
def approve(contract_address,pay_address,get_address, amount,node_index = None,errorcode=47001,errorkey="error"):
if len(get_address)!=34 :
send_get_address=ByteToHex(bytes(get_address, encoding = "utf8"))
else:
send_get_address=Common.bl_address(get_address)
if send_get_address=="0000000000000000000000000000000000000000":
send_get_address=ByteToHex(bytes(get_address, encoding = "utf8"))
if len(pay_address)!=34 :
send_pay_address=ByteToHex(bytes(pay_address, encoding = "utf8"))
else:
send_pay_address=Common.bl_address(pay_address)
if send_pay_address=="0000000000000000000000000000000000000000":
send_pay_address=ByteToHex(bytes(pay_address, encoding = "utf8"))
request = {
"REQUEST": {
"Qid": "t",
"Method": "signeovminvoketx",
"Params": {
"gas_price": 0,
"gas_limit": 1000000000,
"address": contract_address,
"version": 1,
"params": [
{
"type": "string",
"value": "approve"
},
{
"type": "array",
"value": [
{
"type": "bytearray",
"value": send_pay_address
},
{
"type": "bytearray",
"value": send_get_address
},
{
"type": "int",
"value": amount
}
]
}
]
}
},
"RESPONSE":{"error" : errorcode},
"NODE_INDEX":node_index
}
if (errorkey =="error_code"):
request["SIGN_RESPONSE"]={errorkey : errorcode}
if len(contract_address)<=5:
logger.error("contract address error! now is contract address:\"" + contract_address+"\"")
return (False,{"error":10000,"desc":"contract address error!"})
return API.contract().call_contract(Task(name="approve", ijson=request), twice = True,sleep=0)
def deploy_contract_full(self,
neo_code_path,
name="name",
desc="this is desc",
price=0):
try:
if not neo_code_path or neo_code_path == "":
return None
deploy_contract_addr = None
deploy_contract_txhash = None
logger.print("[ DEPLOY ] ")
cmd = Config.TOOLS_PATH + "/deploy_contract.sh " + neo_code_path + " \"" + name + "\" \"" + desc + "\" \"" + str(
price) + "\" > tmp"
logger.print(cmd)
p = subprocess.Popen(cmd,
stderr=subprocess.STDOUT,
stdout=subprocess.PIPE,
shell=True)
begintime = time.time()
secondpass = 0
timeout = 3
while p.poll() is None:
secondpass = time.time() - begintime
if secondpass > timeout:
p.terminate()
logger.error("Error: execute " + cmd + " time out!")
time.sleep(0.1)
p.stdout.close()
tmpfile = open("tmp", "r+") # 打开文件
contents = tmpfile.readlines()
for line in contents:
#for log
logger.print(line.strip('\n'))
for line in contents:
regroup = re.search(r'Contract Address:(([0-9]|[a-z]|[A-Z])*)',
line)
if regroup:
deploy_contract_addr = regroup.group(1)
regroup = re.search(r'TxHash:(([0-9]|[a-z]|[A-Z])*)', line)
if regroup:
deploy_contract_txhash = regroup.group(1)
if deploy_contract_addr and deploy_contract_txhash:
break
tmpfile.close()
nodeapi.wait_tx_result(deploy_contract_txhash)
return (deploy_contract_addr, deploy_contract_txhash)
except Exception as e:
print(e)
return (None, None)
def test_01_dumpprivkey(self):
try:
result = API.rpc().dumpprivkey(
Config.NODES[0]["wallet"].account().address())
self.ASSERT(result is "", "privkey not match")
except AssertError as e:
logger.error(e.msg)
except Exception as e:
logger.error(traceback.format_exc())
def check_connected_nodes(self):
logger.info("----------------------------------")
logger.info("start checking connected node count\n")
connected_node_count = get_connected_nodes()
if connected_node_count != len(Config.NODES) - 1:
logger.error(
"connected node counts : %d, config node counts : %d" %
(connected_node_count, len(Config.NODES) - 1))
logger.info("checking connected node count OK")
logger.info("----------------------------------\n\n")
def ws_heartbeat_thread(self, heartbeat_gap=5):
while True:
time.sleep(heartbeat_gap)
try:
if self.terminated:
raise TestError("Error")
self.LONG_LIVE_WS.send(
json.dumps(
Task(Config.BASEAPI_PATH +
"/ws/heartbeat.json").data()["REQUEST"]))
except Exception as e:
logger.error(str(e.args[0]))
return False
def con_rpc(ip, request):
try:
con_url = ""
if ip:
con_url = "http://" + ip + ":20336/jsonrpc"
else:
con_url = Config.RPC_URL
response = requests.post(con_url,
data=json.dumps(request),
headers=Config.RPC_HEADERS,
timeout=10)
return response.json()
except Exception as e:
logger.error("con_rpc:" + str(e.args[0]))
raise TestError(54001)
def check_tools(self):
logger.info("----------------------------------")
logger.info("start checking all nodes tools\n")
for i in range(self.nodecounts):
logger.info("checking node " + str(i + 1) + " tools......")
response = API.node().check_xmode_tools(i)
if isinstance(response["result"],
str) and "doesnot exists" in response["result"]:
logger.error(response["result"])
logger.info("checking node " + str(i + 1) + " tools OK\n")
logger.info("checking all nodes tools OK")
logger.info("----------------------------------\n\n")
def con_test_service(ip, request):
try:
con_url = ""
if ip:
con_url = "http://" + ip + ":23635/jsonrpc"
else:
con_url = "http://127.0.0.1:23635/jsonrpc"
response = requests.post(con_url,
data=json.dumps(request),
headers=Config.RPC_HEADERS,
timeout=10)
return response.json()
except Exception as e:
logger.error("con_test_service:" + str(e.args[0]))
raise TestError(54005)
def con_ws(ip, request):
try:
url = ""
if ip:
url = "ws://" + ip + ":20335"
else:
url = Config.WS_URL
ws = create_connection(url)
ws.send(json.dumps(request))
response = ws.recv()
ws.close()
return json.loads(response)
except Exception as e:
logger.error("con_ws:" + str(e.args[0]))
raise TestError(54003)
def sftp_transfer(self, _from, _to, remotenode, op="get"):
# on local host
# if _node_index == 0:
# cmd = "cp -rf " + _from + " " + _to
# os.system(cmd)
# return
# private_key = paramiko.RSAKey.from_private_key_file("../../resource/id_rsa", "367wxd")
transport = paramiko.Transport((Config.NODES[remotenode]["ip"], 22))
transport.connect(username=Config.NODES[remotenode]["sshuser"], password=Config.NODES[remotenode]["sshpwd"])
sftp = paramiko.SFTPClient.from_transport(transport)
if op == "put":
sftp.put(_from, _to)
elif op == "get":
sftp.get(_from, _to)
else:
logger.error("operation not supported")
transport.close()
def con_rpc(ip, request):
try:
con_url = ""
if ip:
con_url = "http://" + ip + "/jsonrpc"
else:
con_url = Config.RPC_URL
response = requests.post(con_url,
data=json.dumps(request).replace(
"\"num#!#start-",
"").replace("-num#!#end\"", ""),
headers=Config.RPC_HEADERS,
timeout=10)
return response.json()
except Exception as e:
logger.error("con_rpc:" + str(e.args[0]))
raise RuntimeError(54001)
def check_abi(self):
logger.info("----------------------------------")
logger.info("start checking all nodes abi\n")
for i in range(self.nodecounts):
logger.info("checking node " + str(i + 1) + " abi......")
response = API.node().get_version_abi(i)
if "doesnot exists" in response["result"] or (response["result"] !=
self.abi_md5):
logger.error("node " + str(i + 1) +
" abi version error or not exists")
logger.info("start transfer abi from node 1 to node " +
str(i + 1))
sftp_transfer_dir(self.abi_source_path, self.abi_path, i,
"put")
logger.info("transfer abi OK ")
logger.info("checking node " + str(i + 1) + " abi OK\n")
logger.info("checking all nodes abi OK")
logger.info("----------------------------------\n\n")
def check_test_config(self):
logger.info("----------------------------------")
logger.info("start checking all nodes test config\n")
for i in range(self.nodecounts):
logger.info("checking node " + str(i + 1) + " test config......")
response = API.node().get_version_test_config(i)
if "doesnot exists" in response["result"] or (
response["result"] != self.test_config_md5):
logger.error("node " + str(i + 1) +
" test config version error or not exists")
logger.info("start transfer test config from node 1 to node " +
str(i + 1))
sftp_transfer(self.test_config_source_path,
self.test_config_path, i, "put")
logger.info("transfer test config OK ")
logger.info("checking node " + str(i + 1) + " test config OK\n")
logger.info("checking all nodes test config OK")
logger.info("----------------------------------\n\n")
def check_self_wallets(self):
logger.info("----------------------------------")
logger.info("start checking self wallets\n")
# check wallet amount
files = os.listdir(self.wallet_source_path)
files.sort()
if len(files) != len(Config.NODES):
logger.error(
"wallets number incorrect, wallets : [%d] config : [%d]" %
(len(files), len(Config.NODES)))
address = []
pubkey = []
with open(self.onto_config_source_path) as f:
config_json = json.load(f)
for _file in files:
with open(os.path.join(self.wallet_source_path, _file)) as f:
wallet_json = json.load(f)
address.append(wallet_json["accounts"][0]["address"])
pubkey.append(wallet_json["accounts"][0]["publicKey"])
for nd in config_json["VBFT"]["peers"]:
if not nd["address"] in address:
logger.error("wallet address %s not in onto config" %
nd["address"])
if not nd["peerPubkey"] in pubkey:
logger.error("wallet pubkey %s not in onto config" %
nd["peerPubkey"])
logger.info("checking self wallets OK")
logger.info("----------------------------------\n\n")
def check_sigsvr(self):
logger.info("----------------------------------")
logger.info("start checking all nodes sigsvr\n")
for i in range(self.nodecounts):
logger.info("checking node " + str(i + 1) + " sigsvr......")
response = API.node().get_version_sigsvr(i)
if "doesnot exists" in response["result"] or (
response["result"]["md5"] != self.sigsvr_md5):
logger.error("node " + str(i + 1) +
" sigsvr version error or not exists")
logger.info("start transfer sigsvr from node 1 to node " +
str(i + 1))
sftp_transfer(self.sigsvr_source_path, self.sigsvr_path, i,
"put")
logger.info("transfer sigsvr OK ")
API.node().check_xmode_sigsvr(i)
logger.info("checking node " + str(i + 1) + " sigsvr OK\n")
logger.info("checking all nodes sigsvr OK")
logger.info("----------------------------------\n\n")
def check_wallet(self):
logger.info("----------------------------------")
logger.info("start checking all nodes wallets\n")
for i in range(self.nodecounts):
logger.info("checking node " + str(i + 1) + " wallet......")
response = API.node().get_version_wallet(i)
if "doesnot exists" in response["result"] or (
response["result"] != self.wallet_correct_md5[i]):
logger.error("node " + str(i + 1) +
" wallet version error or not exists")
logger.info("start transfer wallet from node 1 to node " +
str(i + 1))
wallet_index = "0" + str(i) if i < 10 else str(i)
sftp_transfer(
self.wallet_source_path + "/wallet" + wallet_index +
".dat", self.wallet_path, i, "put")
logger.info("transfer wallet OK ")
logger.info("checking node " + str(i + 1) + " wallet OK\n")
logger.info("checking all nodes wallets OK")
logger.info("----------------------------------\n\n")
def check_ontology(self):
logger.info("----------------------------------")
logger.info("start checking all nodes ontology\n")
for i in range(self.nodecounts):
logger.info("checking node " + str(i + 1) + " ontology......")
response = API.node().get_version_ontology(i)
if "doesnot exists" in response["result"] or (
response["result"]["md5"] != self.ontology_correct_md5):
logger.error("node " + str(i + 1) +
" ontology version error or not exists")
logger.info("start transfer ontology from node 1 to node " +
str(i + 1))
sftp_transfer(self.ontology_source_path, self.node_path, i,
"put")
logger.info("transfer ontology OK ")
API.node().check_xmode_ontology(i)
logger.info("checking node " + str(i + 1) + " ontology OK\n")
logger.info("checking all nodes ontology OK")
logger.info("----------------------------------\n\n")
def test_19_getvalidators(self):
try:
result = API.rpc().getvalidators()
self.ASSERT(result, "")
except AssertError as e:
logger.error(e.msg)
except RPCError as e:
logger.error(e.msg)
self.ASSERT(True, "")
except Exception as e:
logger.error(traceback.format_exc())
def test_21_getwalletheight(self):
try:
result = API.rpc().getwalletheight()
self.ASSERT(result, "")
except AssertError as e:
logger.error(e.msg)
except RPCError as e:
logger.error(e.msg)
self.ASSERT(True, "")
except Exception as e:
logger.error(traceback.format_exc())
def test_23_invokefunction(self):
try:
result = API.rpc().invokefunction("", "function", [])
self.ASSERT(result, "")
except AssertError as e:
logger.error(e.msg)
except RPCError as e:
logger.error(e.msg)
self.ASSERT(True, "")
except Exception as e:
logger.error(traceback.format_exc())
def test_25_listaddress(self):
try:
result = API.rpc().listaddress()
self.ASSERT(result, "")
except AssertError as e:
logger.error(e.msg)
except RPCError as e:
logger.error(e.msg)
self.ASSERT(True, "")
except Exception as e:
logger.error(traceback.format_exc())
def test_29_sendmany(self):
try:
result = API.rpc().sendmany([])
self.ASSERT(result, "")
except AssertError as e:
logger.error(e.msg)
except RPCError as e:
logger.error(e.msg)
self.ASSERT(True, "")
except Exception as e:
logger.error(traceback.format_exc())
def test_05_getbestblockhash(self):
try:
result = API.rpc().getbestblockhash()
self.ASSERT(result, "")
except AssertError as e:
logger.error(e.msg)
except RPCError as e:
logger.error(e.msg)
self.ASSERT(True, "")
except Exception as e:
logger.error(traceback.format_exc())
