def test_base_001_consensus(self):
process = False
try:
(process, response) = test_api.transfer(
test_config.m_contract_addr,
Config.NODES[test_config.m_current_node]["address"],
Config.NODES[1]["address"], test_config.AMOUNT,
test_config.m_current_node)
self.ASSERT(process, "transfer error...")
API.node().wait_gen_block()
(process,
response) = API.rpc().getblockheightbytxhash(response["txhash"])
self.ASSERT(process, "not a valid block...")
except Exception as e:
logger.print(e.args[0])
def test_normal_100_getmerkleproof(self):
try:
(process,
response) = API.native().transfer_ont(Config.NODES[0]["address"],
Config.NODES[1]["address"],
"100000000",
0,
twice=True,
check_state=False)
tx_hash_failed = response["txhash"]
API.node().wait_tx_result(tx_hash_failed)
(process, response) = API.ws().getmerkleproof(tx_hash_failed)
self.ASSERT(process, "")
except Exception as e:
logger.print(e.args[0])
def setUp(self):
logger.open("test_benefit_model/" + self._testMethodName + ".log",
self._testMethodName)
if self._testMethodName == "test_init":
return
self.m_checknode = 4
time.sleep(2)
print("stop all")
API.node().stop_all_nodes()
print("start all")
API.node().start_nodes([0, 1, 2, 3, 4, 5, 6], Config.DEFAULT_NODE_ARGS,
True, True)
for i in range(7):
API.native().regid_with_publickey(i)
API.native().init_ont_ong()
def test_normal_017_consensus(self):
process = False
try:
storage_key = ByteToHex(b'Test Key 17')
storage_value = ByteToHex(b'Test Value 17')
(process, response) = API.contract().invoke_function(
test_config.m_contract_addr,
"put",
"",
"1",
argvs=[{
"type": "bytearray",
"value": storage_key
}, {
"type": "bytearray",
"value": storage_value
}],
node_index=test_config.m_current_node)
self.ASSERT(process, "invoke_function put error...")
process = API.node().check_node_state([0, 1, 2, 3, 4, 5, 6])
self.ASSERT(process, "check_node_state")
except Exception as e:
logger.print(e.args[0])
class test_config():
testpath = os.path.dirname(os.path.realpath(__file__))
node_index = API.node().get_current_node() ###7-25暂时不存在
address = Config.NODES[node_index]["address"]
cost1 = testpath + "/resource/cost_1.neo"
task004 = {
"DEPLOY": True,
"CODE_PATH": testpath + "/resource/cost_4.neo",
"REQUEST": {
"Qid": "t",
"Method": "signeovminvoketx",
"Params": {
"gas_price":
10,
"gas_limit":
1000000000,
"address":
"6408c4cc6c55700e96c38db184f3c1de8a260b02",
"version":
1,
"params": [{
"type": "string",
"value": "run"
}, {
"type": "array",
"value": [{
"type": "int",
"value": "1000"
}]
}]
}
},
"RESPONSE": {}
}
def test_normal_005_benefit(self):
try:
process = False
#启动拜占庭节点
API.node().stop_nodes(self.m_dbft_nodes)
API.node().start_nodes(self.m_dbft_nodes,
Config.DEFAULT_NODE_ARGS,
True,
True,
program="ontology-bft_1")
(process, response) = API.native().update_global_param(
"0", "1000", "32", "1", "50", "50", "5", "5")
self.BLOCK(process, "updateGlobalParam error")
(process, response) = API.rpc().getbalance(
Config.NODES[self.m_checknode]["address"])
self.BLOCK(process, "get balance error")
ong1 = int(response["result"]["ong"])
(process, response) = API.rpc().getbalance(
Config.NODES[self.m_dbft_nodes[0]]["address"])
self.BLOCK(process, "get balance error")
dbft_ong1 = int(response["result"]["ong"])
#进行第一轮共识
(process, response) = API.native().commit_dpos(sleep=0)
self.BLOCK(process, "commit_dpos error")
API.node().wait_gen_block()
(process, response) = API.native().transfer_ont(
Config.NODES[0]["address"],
Config.NODES[0]["address"],
"1",
gas_price=test_config.PRICE_TEST)
(process, response) = API.native().commit_dpos(sleep=0)
self.BLOCK(process, "commit_dpos error")
API.node().wait_gen_block()
(process, response) = API.rpc().getbalance(
Config.NODES[self.m_checknode]["address"])
self.BLOCK(process, "get balance error")
ong2 = int(response["result"]["ong"])
(process, response) = API.rpc().getbalance(
Config.NODES[self.m_dbft_nodes[0]]["address"])
self.BLOCK(process, "get balance error")
dbft_ong2 = int(response["result"]["ong"])
#第二轮判断
except_benifit = int(
test_api.get_benifit_value(
20000 * test_config.PRICE_TEST * 0.5, 10000,
[10000, 10000, 10000, 10000, 10000, 10000, 10000]))
self.ASSERT((dbft_ong2 != dbft_ong1), "bft node benefit error")
self.ASSERT((ong2 != ong1), "normal node benefit error")
except Exception as e:
logger.print(e.args[0])
def test_abnormal_031_consensus(self):
try:
test_api.init()
# ensure balance of wallet A is 1000
balance_of_wallet_A = int(API.rpc().getbalance(
test_config.ADDRESS_A)[1]["result"]["ont"])
(process, response) = API.native().transfer_ont(
test_config.ADDRESS_A, test_config.ADDRESS_B,
str(balance_of_wallet_A - 1000), 0)
API.node().wait_gen_block()
(process,
response) = API.native().approve_ont(test_config.ADDRESS_A,
test_config.ADDRESS_B,
"1000",
0,
sleep=0)
(process,
response) = API.native().approve_ont(test_config.ADDRESS_A,
test_config.ADDRESS_C,
"1000",
0,
sleep=0)
API.node().wait_gen_block()
balance_of_wallet_A = int(API.rpc().getbalance(
test_config.ADDRESS_A)[1]["result"]["ont"])
self.ASSERT(balance_of_wallet_A == 1000,
"wallet A balance changed")
(process,
responseb) = API.native().allowance_ont(test_config.ADDRESS_A,
test_config.ADDRESS_B, 0)
# need to check
#self.ASSERT(response["result"] == "00" , "allowance to wallet B is not 0")
(process,
responsec) = API.native().allowance_ont(test_config.ADDRESS_A,
test_config.ADDRESS_C, 0)
# need to checkADDRESS_C
#e803 == 1000 num
self.ASSERT(
responseb["result"]["Result"] == "e803"
or responsec["result"]["Result"] == "e803",
"allowance to wallet B/C is not 0")
except Exception as e:
logger.print(e.args[0])
def test_base_030_consensus(self):
try:
test_api.init()
# ensure balance of wallet A is 1000
balance_of_wallet_A1 = int(API.rpc().getbalance(
test_config.ADDRESS_A)[1]["result"]["ont"])
(process, response) = API.native().transfer_ont(
test_config.ADDRESS_A, test_config.ADDRESS_B,
str(balance_of_wallet_A1 - 1000), 0)
balance_of_wallet_A1 = int(API.rpc().getbalance(
test_config.ADDRESS_A)[1]["result"]["ont"])
balance_of_wallet_B1 = int(API.rpc().getbalance(
test_config.ADDRESS_B)[1]["result"]["ont"])
balance_of_wallet_C1 = int(API.rpc().getbalance(
test_config.ADDRESS_C)[1]["result"]["ont"])
(process,
response) = API.native().transfer_ont(test_config.ADDRESS_A,
test_config.ADDRESS_B,
"1000",
0,
sleep=0)
(process,
response) = API.native().transfer_ont(test_config.ADDRESS_A,
test_config.ADDRESS_C,
"1000",
0,
sleep=0)
API.node().wait_gen_block()
balance_of_wallet_A2 = int(API.rpc().getbalance(
test_config.ADDRESS_A)[1]["result"]["ont"])
balance_of_wallet_B2 = int(API.rpc().getbalance(
test_config.ADDRESS_B)[1]["result"]["ont"])
balance_of_wallet_C2 = int(API.rpc().getbalance(
test_config.ADDRESS_C)[1]["result"]["ont"])
self.ASSERT(balance_of_wallet_A2 == 0,
"wallet A balance changed[1]")
self.ASSERT((balance_of_wallet_A1 + balance_of_wallet_B1 +
balance_of_wallet_C1) == (balance_of_wallet_A2 +
balance_of_wallet_B2 +
balance_of_wallet_C2),
"wallet A balance changed[2]")
except Exception as e:
logger.print(e.args[0])
def test_normal_006_benefit(self):
try:
process = False
(process, response) = API.native().update_global_param(
"0", "1000", "32", "1", "50", "50", "5", "5")
self.BLOCK(process, "updateGlobalParam error")
(process, response) = API.rpc().getbalance(
Config.NODES[self.m_checknode]["address"])
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)
(process, response) = API.rpc().getbalance(
Config.NODES[self.m_checknode]["address"])
self.BLOCK(process, "get balance error")
ong2 = int(response["result"]["ong"])
#第一轮判断
self.ASSERT(ong1 == ong2, "benefit error")
#进行第一轮共识
(process, response) = API.native().commit_dpos(sleep=0)
self.BLOCK(process, "commit_dpos error")
API.node().wait_gen_block()
(process, response) = API.rpc().getbalance(
Config.NODES[self.m_checknode]["address"])
self.BLOCK(process, "get balance error")
ong3 = int(response["result"]["ong"])
#第二轮判断
except_benifit = int(
test_api.get_benifit_value(
20000 * test_config.PRICE_TEST * 0.5, 10000,
[10000, 10000, 10000, 10000, 10000, 10000, 10000]))
self.ASSERT((ong3 - ong2) == except_benifit, "first benefit error")
except Exception as e:
logger.print(e.args[0])
def test_abnormal_012_consensus(self):
process = False
try:
storage_key = ByteToHex(b'Test Key 12')
storage_value = ByteToHex(b'Test Value 12')
for i in range(1, 4):
self.init_bft_node(i)
API.node().wait_gen_block()
time.sleep(5)
#A节点是Admin节点
(process, response) = API.contract().init_admin(
test_config.m_contract_addr, Config.ontID_A, sleep=0)
self.ASSERT(process, "init_admin error...")
API.node().wait_gen_block()
time.sleep(2)
(process, response) = API.native().bind_role_function(
test_config.m_contract_addr,
Config.ontID_A,
Config.roleA_hex, ["auth_put"],
sleep=0)
self.ASSERT(process, "bind_role_function error...")
API.node().wait_gen_block()
time.sleep(2)
(process, response) = API.contract().invoke_function(
test_config.m_contract_addr,
"auth_put",
Config.ontID_B,
"1",
argvs=[{
"type": "bytearray",
"value": storage_key
}, {
"type": "bytearray",
"value": storage_value
}],
sleep=0)
self.ASSERT(process, "invoke_function put error...")
API.node().wait_gen_block()
time.sleep(2)
(process, response) = API.contract().invoke_function(
test_config.m_contract_addr,
"get",
Config.ontID_B,
"1",
argvs=[{
"type": "bytearray",
"value": storage_key
}])
self.ASSERT(response["result"]["Result"] == '',
"invoke_function get error...")
except Exception as e:
logger.print(e.args[0])
def test_normal_011_consensus(self):
process = False
try:
storage_key = ByteToHex(b'Test Key 11')
storage_value = ByteToHex(b'Test Value 11')
for i in range(1, 4):
self.init_bft_node(i)
API.node().wait_gen_block()
time.sleep(5)
(process, response) = API.contract().invoke_function(
test_config.m_contract_addr,
"put",
"",
"1",
argvs=[{
"type": "bytearray",
"value": storage_key
}, {
"type": "bytearray",
"value": storage_value
}],
node_index=test_config.m_current_node,
sleep=0)
self.ASSERT(process, "invoke_function put error...")
API.node().wait_gen_block()
time.sleep(5)
(process, response) = API.contract().invoke_function(
test_config.m_contract_addr,
"get",
"",
"1",
argvs=[{
"type": "bytearray",
"value": storage_key
}],
node_index=test_config.m_current_node)
self.ASSERT(process, "invoke_function error...[1]")
self.ASSERT(response["result"]["Result"] == storage_value,
"invoke_function error...[2]")
except Exception as e:
logger.print(e.args[0])
def test_init(self):
API.node().stop_all_nodes()
API.node().start_nodes([0, 1, 2, 3, 4, 5, 6], Config.DEFAULT_NODE_ARGS, True, True)
time.sleep(10)
while True:
if API.rpc().getblockcount()[1]["result"] > 0:
break
time.sleep(1)
(test_config.m_contractaddr_right, test_config.m_txhash_right) = API.contract().deploy_contract_full(testpath+"/resource/A.neo", "name", "desc", 0)
time.sleep(5)
(result, reponse) = API.rpc().getblockhash(height = 1)
test_config.m_block_hash_right = reponse["result"]
(result, reponse) = API.contract().sign_transction(Task(testpath+"/resource/cli/siginvoketx.json"), False)
test_config.m_signed_txhash_right = reponse["result"]["signed_tx"]
test_config.m_signed_txhash_wrong = "0f0f0f0f" + test_config.m_signed_txhash_right
API.contract().invoke_function(test_config.m_contractaddr_right, "put", "", "1", argvs = [{"type": "bytearray","value": test_config.m_getstorage_contract_key},{"type": "bytearray","value": test_config.m_getstorage_contract_value}], node_index = 0)
def test_normal_013_gover(self):
process = False
try:
(wallet_A_address, wallet_B_address, vote_price, node_B_puiblic_key, blocks_per_round, punish_ratio) = test_api.get_config()
API.native().update_global_param("2000000000","10000","32","1","50","50","50","50")
# step 1 wallet A vote for node B
(process, response) = API.native().vote_for_peer(wallet_A_address, [node_B_puiblic_key], [vote_price], 8)
self.ASSERT(process, "vote_for_peer error")
API.node().wait_gen_block()
# step 2 wait until the second round
API.native().commit_dpos()
time.sleep(15)
(process, response) = API.native().black_node([node_B_puiblic_key])
self.ASSERT(process, "black_node error")
API.node().wait_gen_block()
# step 3 wallet A withdraw ont in the third round
API.native().commit_dpos()
time.sleep(10)
(process, response) = API.native().withdraw_ont(wallet_A_address, [node_B_puiblic_key], [vote_price], 8)
self.ASSERT(not process, "withdraw_ont1 error")
# step 4 wallet A withdraw ont in the forth round
API.native().commit_dpos()
time.sleep(10)
API.native().commit_dpos()
time.sleep(10)
(process, response) = API.native().withdraw_ont(wallet_A_address, [node_B_puiblic_key], [str(int(punish_ratio*3000))], 8)
self.ASSERT(process, "withdraw_ont2 error")
# this should be failed
(process, response) = API.native().withdraw_ont(wallet_A_address, [node_B_puiblic_key], ["1"], 8)
self.ASSERT(not process, "withdraw_ont3 error")
except Exception as e:
logger.print(e.args[0])
def test_normal_004_benefit(self):
try:
process = False
address_stop = Config.NODES[self.m_stop_2_nodes[0]]["address"]
(process, response) = API.rpc().getbalance(address_stop)
self.BLOCK(process, "get balance error[1]")
ong_stop1 = int(response["result"]["ong"])
API.node().stop_nodes(self.m_stop_2_nodes)
address1 = Config.NODES[1]["address"]
(process, response) = API.rpc().getbalance(address1)
self.BLOCK(process, "get balance error[2]")
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, "commit_dpos error")
API.node().wait_gen_block()
(process, response) = API.rpc().getbalance(address1)
self.BLOCK(process, "get balance error[3]")
ong2 = int(response["result"]["ong"])
self.BLOCK(ong2 != ong1, "no benefit[1]")
#start_nodes(self.m_stop_2_nodes)
#time.sleep(10)
(process, response) = API.rpc().getbalance(address_stop)
self.BLOCK(process, "get balance error[4]")
ong_stop2 = int(response["result"]["ong"])
print("no benefit, before cost[1]: " + str(ong_stop1))
print("no benefit, after cost[1]: " + str(ong_stop2))
self.ASSERT(ong_stop2 != ong_stop1, "benefit[2]")
except Exception as e:
logger.print(e.args[0])
process = False
def recover_env(self):
print("recover env...")
#restart node
API.node().stop_all_nodes()
API.node().start_nodes(range(len(Config.NODES)), clear_chain = True, clear_log = True)
#restart sigserver
for node_index in range(len(Config.NODES)):
API.node().stop_sigsvr(node_index)
API.node().start_sigsvr(Config.NODE_PATH + "/wallet.dat", node_index)
time.sleep(10)
return True
def sample(contract_address,
pay_address,
get_address,
node_index,
charge=False,
nodePath=""):
#getont/ong
(result1, response) = API.rpc().getbalance(get_address)
transfervalue1ont = int(response["result"]["ont"])
transfervalue1ong = int(response["result"]["ong"])
##case
if (charge):
os.system(
"echo 123456 | " + nodePath + "/ontology asset transfer --from=" +
pay_address +
" --to=1 --amount=10 --gasprice=0 --gaslimit=30000 --asset=ont -w "
+ nodePath + "/wallet.dat")
API.node().wait_gen_block(True)
os.system(
"echo 123456 | " + nodePath + "/ontology asset transfer --from=" +
pay_address +
" --to=1 --amount=0.00000001 --gasprice=0 --gaslimit=30000 --asset=ong -w "
+ nodePath + "/wallet.dat")
else:
(result, response) = forNeo(contract_address, pay_address, get_address,
node_index)
#API.node().wait_gen_block()
API.node().wait_gen_block(True)
#getont/ong
(result2, response1) = API.rpc().getbalance(get_address)
transfervalue2ont = int(response1["result"]["ont"])
transfervalue2ong = int(response1["result"]["ong"])
changevalue = 10
result1 = (transfervalue2ont - transfervalue1ont == changevalue)
result2 = (transfervalue2ong - transfervalue1ong == changevalue)
print(result1)
print(result2)
return result1 & result2
def setUp(self):
logger.open("test_benefit_model/" + self._testMethodName + ".log",
self._testMethodName)
if self._testMethodName == "test_init":
return
API.node().stop_all_nodes()
API.node().start_nodes([0, 1, 2, 3, 4, 5, 6], Config.DEFAULT_NODE_ARGS,
True, True)
for i in range(7):
API.native().regid_with_publickey(i, sleep=0)
API.native().init_ont_ong(sleep=0)
time.sleep(5)
self.m_current_node = 0
self.m_stop_2_nodes = [5, 6]
self.m_new_2_nodes = [7, 8]
self.m_checknode = 4
self.m_dbft_nodes = [5, 6] #拜占庭节点
def init_bft_node(self, bft_index):
API.node().stop_all_nodes()
API.node().start_nodes([0, 1, 2, 3, 4],
Config.DEFAULT_NODE_ARGS,
True,
True,
program="ontology")
logger.info("start bft node: " + "ontology-bft_" + str(bft_index))
API.node().start_nodes([5, 6],
Config.DEFAULT_NODE_ARGS,
True,
True,
program="ontology-bft_" + str(bft_index))
for node_index in range(7):
API.native().regid_with_publickey(node_index)
API.native().init_ont_ong()
(test_config.m_contract_addr,
test_config.m_contract_txhash) = API.contract().deploy_contract_full(
test_config.deploy_neo_1, test_config.name1, test_config.desc,
test_config.price)
(test_config.m_contract_addr2,
test_config.m_contract_txhash2) = API.contract().deploy_contract_full(
test_config.deploy_neo_2, test_config.name1, test_config.desc,
test_config.price)
def test_normal_003_gover(self): process = False try: (wallet_A_address, wallet_B_address, vote_price, node_B_puiblic_key, blocks_per_round, punish_ratio) = test_api.get_config() # step 1 wallet A vote for node B (process, response) = API.native().vote_for_peer(wallet_A_address, [node_B_puiblic_key], [vote_price], 8) self.ASSERT(process, "vote_for_peer error") # step 2 wallet A unvote in the second round API.native().commit_dpos() #API.node().wait_gen_block() time.sleep(10) (process, response) = API.native().unvote_for_peer(wallet_A_address, [node_B_puiblic_key], [vote_price], 8) self.ASSERT(process, "unvote_for_peer error") API.node().wait_gen_block() # step 3 wallet A withdraw ont in the third round API.native().commit_dpos() API.node().wait_gen_block() API.native().commit_dpos() API.node().wait_gen_block() (process, response) = API.native().withdraw_ont(wallet_A_address, [node_B_puiblic_key], [vote_price], 8) self.ASSERT(process, "withdraw_ont error") # this should be failed (process, response) = API.native().withdraw_ont(wallet_A_address, [node_B_puiblic_key], ["1"], 8) self.ASSERT(not process, "withdraw_ont error") except Exception as e: logger.print(e.args[0])
def test_init(self):
time.sleep(2)
print("stop all")
API.node().stop_all_nodes()
print("start all")
API.node().start_nodes([0,1,2,3,4,5,6], Config.DEFAULT_NODE_ARGS, True, True)
time.sleep(60)
print("waiting for 60s......")
(test_config.contract_addr, test_config.contract_tx_hash) = API.contract().deploy_contract_full(testpath+"/resource/test.neo")
API.node().wait_gen_block()
test_config.CONTRACT_ADDRESS_CORRECT = test_config.contract_addr
test_config.CONTRACT_ADDRESS_INCORRECT_2 = test_config.contract_addr + "11"
test_config.TX_HASH_CORRECT = test_config.contract_tx_hash
test_config.TX_HASH_INCORRECT_2 = test_config.contract_tx_hash[:-2]
test_config.TX_HASH_INCORRECT_3 = test_config.contract_tx_hash + "1111"
test_config.block_height = int(API.rpc().getblockcount()[1]["result"]) - 1
test_config.block_hash = API.rpc().getblockhash(test_config.block_height - 1)[1]["result"]
test_config.signed_data = get_signed_data()
test_config.HEIGHT_CORRECT = test_config.block_height - 1
test_config.HEIGHT_INCORRECT_2 = test_config.block_height + 1000
test_config.BLOCK_HASH_CORRECT = test_config.block_hash
test_config.BLOCK_HASH_INCORRECT_2 = test_config.block_hash[:-2] # HASH NOT EXISTENT
test_config.BLOCK_HASH_INCORRECT_3 = test_config.block_hash + "1111"
test_config.RAW_TRANSACTION_DATA_CORRECT = test_config.signed_data
test_config.RAW_TRANSACTION_DATA_INCORRECT_2 = "11111111" + test_config.signed_data + "1111111111"
def add_candidate_node(new_node, init_ont = 100000, init_ong = 1000000000000, init_pos = 10000, from_node = 0):
#新加入节点, 并申请候选节点
API.node().start_nodes([new_node], clear_chain = True, clear_log = True)
API.native().regid_with_publickey(new_node)
(process, response) = API.native().bind_role_function("0700000000000000000000000000000000000000", ByteToHex(bytes(Config.NODES[0]["ontid"], encoding = "utf8")), ByteToHex(b"roleA"),["registerCandidate"])
if not process:
return (process, response)
(process, response) = API.native().bind_user_role("0700000000000000000000000000000000000000",ByteToHex(bytes(Config.NODES[0]["ontid"], encoding = "utf8")), ByteToHex(b"roleA"),[ByteToHex(bytes(Config.NODES[new_node]["ontid"], encoding = "utf8"))])
if not process:
return (process, response)
API.native().transfer_ont(Config.NODES[from_node]["address"], Config.NODES[new_node]["address"], str(init_ont), 0)
API.native().transfer_ong(Config.NODES[from_node]["address"], Config.NODES[new_node]["address"], str(init_ong), 0)
time.sleep(10)
(process, response) = API.native().register_candidate(Config.NODES[new_node]["pubkey"], Config.NODES[new_node]["address"], str(init_pos), ByteToHex(bytes(Config.NODES[new_node]["ontid"], encoding = "utf8")), "1", new_node)
if not process:
return (process, response)
(process, response) = API.native().approve_candidate(Config.NODES[new_node]["pubkey"])
return (process, response)
def check_test_service(self):
logger.info("----------------------------------")
logger.info("start checking all nodes test service\n")
for i in range(self.nodecounts):
logger.info("checking node " + str(i + 1) + " test service......")
response = API.node().get_version_test_service(i)
if "doesnot exists" in response["result"] or (
response["result"] != self.test_service_md5):
logger.error("node " + str(i + 1) +
" test service version error or not exists")
logger.info(
"start transfer test service from node 1 to node " +
str(i + 1))
sftp_transfer(self.test_service_source_path,
self.test_service_path, i, "put")
logger.info("transfer test service OK ")
API.node().stop_test_service(i)
logger.info("checking node " + str(i + 1) + " test service OK\n")
logger.info("checking all nodes test service 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_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_normal_009_consensus(self):
try:
stopnodes = test_config.m_stop_2_nodes
API.node().stop_nodes(stopnodes)
process = False
for i in range(10):
storage_key = ByteToHex(
bytes("Test Key 09-" + str(i), encoding="utf8"))
storage_value = ByteToHex(
bytes("Test Value 09-" + str(i), encoding="utf8"))
logger.print("times: " + str(i))
(process, response) = API.contract().invoke_function(
test_config.m_contract_addr,
"put",
"",
"1",
argvs=[{
"type": "bytearray",
"value": storage_key
}, {
"type": "bytearray",
"value": storage_value
}],
node_index=test_config.m_current_node)
self.ASSERT(process, "invoke_function put error...")
time.sleep(30)
(process, response) = API.rpc().getblockheightbytxhash(
response["txhash"])
self.ASSERT(process,
"not a valid block...in " + str(i) + " times")
time.sleep(10)
API.node().start_nodes(stopnodes, Config.DEFAULT_NODE_ARGS)
except Exception as e:
logger.print(e.args[0])
def test_normal_034_consensus(self):
process = False
try:
vote_node = 13 #投票节点
peer_node1 = 7 #被投票节点1
peer_node2 = 8 #被投票节点2
peer_node3 = 9 #被投票节点3
API.node().start_nodes([vote_node], Config.DEFAULT_NODE_ARGS, True,
True)
API.native().transfer_ont(Config.NODES[0]["address"],
Config.NODES[vote_node]["address"],
"1000000", 0)
API.native().transfer_ong(Config.NODES[0]["address"],
Config.NODES[vote_node]["address"],
"1000000000000", 0)
for i in range(7, 14):
test_api.add_candidate_node(i, init_pos=10000, from_node=0)
(process, response) = API.native().vote_for_peer(
Config.NODES[vote_node]["address"], [
Config.NODES[peer_node1]["pubkey"],
Config.NODES[peer_node2]["pubkey"],
Config.NODES[peer_node3]["pubkey"]
], ["15000", "15000", "15000"])
self.ASSERT(process, "vote_for_peer error")
test_api.getStorageConf("vbftConfig")
# step 2 wallet A unvote in the second round
(process, response) = API.native().commit_dpos()
API.node().wait_gen_block()
test_api.getStorageConf("vbftConfig")
self.ASSERT(process, "")
except Exception as e:
logger.print(e.args[0])
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 test_init(self):
API.node().stop_all_nodes()
API.node().start_nodes([0, 1, 2, 3, 4, 5, 6], Config.DEFAULT_NODE_ARGS,
True, True)
time.sleep(10)
(test_config.contract_address,
_) = API.contract().deploy_contract_full(
testpath + "/resource/test_op.avm", "name", "desc", 0)
API.node().wait_gen_block()
def init(node_index=7,
candidate=False,
register_ontid=False,
restart=False,
pub_key="1",
ont_count="10000"):
'''
restart all nodes
register ONTID
create role and bind ONTID with role
be candidate or not
'''
# restart all nodes
if restart:
API.node().stop_all_nodes()
API.node().start_nodes(range(0, 8),
Config.DEFAULT_NODE_ARGS,
clear_chain=True,
clear_log=True)
API.native().init_ont_ong(node_count=8)
# register ONTID
if register_ontid:
API.native().regid_with_publickey(0, sleep=0)
API.native().regid_with_publickey(node_index, sleep=0)
API.node().wait_gen_block()
if candidate:
# create role and bind ONTID with role
(process, response) = API.native().bind_role_function(
"0700000000000000000000000000000000000000",
ByteToHex(bytes(Config.NODES[0]["ontid"], encoding="utf8")),
ByteToHex(b"roleA"), ["registerCandidate"])
(process, response) = API.native().bind_user_role(
"0700000000000000000000000000000000000000",
ByteToHex(bytes(Config.NODES[0]["ontid"], encoding="utf8")),
ByteToHex(b"roleA"),
[ByteToHex(bytes(Config.NODES[7]["ontid"], encoding="utf8"))])
API.node().wait_gen_block()
def setUp(self):
logger.open("test_governance/" + self._testMethodName + ".log",self._testMethodName)
# return
time.sleep(2)
print("stop all")
API.node().stop_all_nodes()
print("start all")
API.node().start_nodes([0,1,2,3,4,5,6,7,8], Config.DEFAULT_NODE_ARGS, True, True)
for i in range(9):
API.native().regid_with_publickey(i, sleep=0)
API.native().init_ont_ong()
API.native().transfer_ont(Config.NODES[0]["address"], Config.NODES[7]["address"], "1000000", 0)
API.native().transfer_ong(Config.NODES[0]["address"], Config.NODES[7]["address"], "1000000000000", 0)
API.native().transfer_ont(Config.NODES[0]["address"], Config.NODES[8]["address"], "1000000", 0)
API.native().transfer_ong(Config.NODES[0]["address"], Config.NODES[8]["address"], "1000000000000", 0)
try:
# create role and bind ONTID with role
(process, response) = API.native().bind_role_function("0700000000000000000000000000000000000000", ByteToHex(bytes(Config.NODES[0]["ontid"], encoding = "utf8")), ByteToHex(b"roleA"),["registerCandidate"], sleep=1)
if not process:
raise Error("bind_role_function error")
(process, response) = API.native().bind_user_role("0700000000000000000000000000000000000000",ByteToHex(bytes(Config.NODES[0]["ontid"], encoding = "utf8")), ByteToHex(b"roleA"),[ByteToHex(bytes(Config.NODES[7]["ontid"], encoding = "utf8"))], sleep=1)
if not process:
raise Error("bind_user_role error")
(process, response) = API.native().bind_user_role("0700000000000000000000000000000000000000",ByteToHex(bytes(Config.NODES[0]["ontid"], encoding = "utf8")), ByteToHex(b"roleA"),[ByteToHex(bytes(Config.NODES[8]["ontid"], encoding = "utf8"))], sleep=1)
if not process:
raise Error("bind_user_role error")
(process, response) = API.native().register_candidate(Config.NODES[7]["pubkey"], Config.NODES[7]["address"] ,"10000", ByteToHex(bytes(Config.NODES[7]["ontid"], encoding = "utf8")), "1", 7, sleep=1)
if not process:
raise Error("register_candidate error")
(process, response) = API.native().approve_candidate(Config.NODES[7]["pubkey"], sleep=1)
if not process:
raise Error("approve_candidate error")
(process, response) = API.native().register_candidate(Config.NODES[8]["pubkey"], Config.NODES[8]["address"] ,"10000", ByteToHex(bytes(Config.NODES[8]["ontid"], encoding = "utf8")), "1", 8, sleep=1)
if not process:
raise Error("register_candidate error")
(process, response) = API.native().approve_candidate(Config.NODES[8]["pubkey"], sleep=1)
if not process:
raise Error("invoke_function_aapprove_candidatepprove error")
API.node().wait_gen_block()
except Exception as e:
logger.print(e.args[0])
