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])