def test_44_get_storage(self): script_hash = "" key = self.m_getstorage_contract_key logger.open("restful/44_get_storage.log", "44_get_storage") (result, response) = RestfulApi().getstorage(script_hash, key) logger.close(not result)
def test_48_get_storage(self): script_hash = self.m_getstorage_contract_addr key = self.m_getstorage_contract_key + "1111" logger.open("restful/48_get_storage.log", "48_get_storage") (result, response) = RestfulApi().getstorage(script_hash, key) logger.close(result)
def test_54_get_contract_state(self): script_hash = self.m_contractaddr_wrong logger.open("restful/54_get_contract_state.log", "54_get_contract_state") (result, response) = RestfulApi().getcontract(script_hash) logger.close(not result)
def test_04_get_conn_count(self): stop_nodes([1, 2, 3, 4, 5, 6]) logger.open("restful/04_get_conn_count.log", "04_get_conn_count") (result, response) = RestfulApi().getconnectioncount() logger.close(result and int(response["result"]) == 0) start_nodes([1, 2, 3, 4, 5, 6], Config.DEFAULT_NODE_ARGS, True, True) time.sleep(10)
def test_17_consensus(self): result = False logger.open("17_consensus.log", "17_consensus") storage_key = ByteToHex(b'Test Key 17') storage_value = ByteToHex(b'Test Value 17') try: (result, response) = invoke_function(self.m_contract_addr, "put", "", "1", argvs=[{ "type": "bytearray", "value": storage_key }, { "type": "bytearray", "value": storage_value }], node_index=self.m_current_node) if not result: raise Error("invoke_function put error...") result = check_node_state([0, 1, 2, 3, 4, 5, 6]) except Exception as e: print(e.msg) result = False logger.close(result)
def test_67_get_blk_hgt_by_txhash(self): hash = self.m_txhash_wrong logger.open("restful/67_get_blk_hgt_by_txhash.log", "67_get_blk_hgt_by_txhash") (result, response) = RestfulApi().getblockheightbytxhash(hash) logger.close(not result)
def test_08_consensus(self): stopnodes = self.m_stop_2_nodes stop_nodes(stopnodes) result = False logger.open("08_consensus.log", "08_consensus") try: (result, response) = transfer(self.m_contract_addr, Config.NODES[self.m_current_node]["address"], Config.NODES[1]["address"], self.AMOUNT, self.m_current_node) if not result: raise Error("transfer error...") (result, response) = RPCApi().getblockheightbytxhash(response["txhash"]) if not result: raise Error("not a valid block...") except Exception as e: print(e.msg) result = False logger.close(result) start_nodes(stopnodes, Config.DEFAULT_NODE_ARGS) time.sleep(3)
def test_13_consensus(self): result = False logger.open("13_consensus.log", "13_consensus") storage_key = ByteToHex(b'Test Key 13') storage_value = ByteToHex(b'Test Value 13') try: for i in range(1, 4): self.init_bft_node(i) time.sleep(30) for j in range(10): (result, response) = invoke_function( self.m_contract_addr, "put", "", "1", argvs=[{ "type": "bytearray", "value": storage_key }, { "type": "bytearray", "value": storage_value }], node_index=self.m_current_node) if not result: raise Error("invoke_function put error...") time.sleep(10) except Exception as e: print(e.msg) result = False logger.close(result)
def test_10_consensus(self): result = False storage_key = ByteToHex(b'Test Key 10') storage_value = ByteToHex(b'Test Value 10') logger.open("10_consensus.log", "10_consensus") try: for i in range(1, 4): self.init_bft_node(i) time.sleep(30) (result, response) = invoke_function(self.m_contract_addr, "put", "", "1", argvs=[{ "type": "bytearray", "value": storage_key }, { "type": "bytearray", "value": storage_value }], node_index=self.m_current_node) if not result: raise Error("invoke_function error...") (result, response) = RPCApi().getblockheightbytxhash( response["txhash"]) if not result: raise Error("not a valid block...") except Exception as e: print(e.msg) result = False logger.close(result)
def setUp(self): logger.open("test_rpc/" + self._testMethodName + ".log", self._testMethodName) API.node().stop_all_nodes() API.node().start_nodes([0, 1, 2, 3, 4, 5, 6], Config.DEFAULT_NODE_ARGS, True, True) time.sleep(5)
def test_main(self): result = False logger.open("TestGover7.log", "TestGover7") try: if (not pause( "ensure that node A and node B is in the nodes network and node A has more than 10000 ont." )): raise Error("pre-condition unsatisfied") (wallet_A_address, wallet_B_address, vote_price, node_B_puiblic_key, blocks_per_round, punish_ratio) = get_config() consensus_rounds = (int)(getblockcount() / blocks_per_round) # step 1 wallet A vote for node B (result, response) = vote_for_peer(wallet_A_address, [node_B_puiblic_key], [vote_price]) print(response) #if not result: # raise Error("vote error") # step 2 wallet A unvote in the second round while (True): if (getblockcount() / blocks_per_round - consensus_rounds == 1): (result, response) = unvote_for_peer(wallet_A_address, [node_B_puiblic_key], [vote_price]) break else: time.sleep(5) continue #if not result: # raise Error("unvote error") # step 3 wallet A withdraw ont in the third round while (True): if (getblockcount() / blocks_per_round - consensus_rounds == 2): (result, response) = withdraw_ont(wallet_A_address, [node_B_puiblic_key], [vote_price]) break else: time.sleep(5) continue #if not result: # raise Error("withdraw_ont error") # this should be failed (result, response) = withdraw_ont(wallet_A_address, [node_B_puiblic_key], ["1"]) #if not result: # raise Error("withdraw_ont error") except Exception as e: print(e.msg) logger.close(result)
def test_gov_16(self): result = False logger.open("TestGover16.log", "TestGover16") try: (wallet_A_address, wallet_B_address, vote_price, node_B_puiblic_key, blocks_per_round, punish_ratio) = get_config() invoke_function_update("updateGlobalParam", "2000000000", "10000", "32", "10", "50", "50", "50", "50") # step 1 wallet A vote for node B (result, response) = vote_for_peer_index(Config.NODES[8]["address"], [node_B_puiblic_key], ["90000"], 8) print(response) #if not result: # raise Error("vote_for_peer error") # step 1 wallet A vote for node B (result, response) = vote_for_peer_index(wallet_A_address, [node_B_puiblic_key], ["10001"]) print(response) #if not result: # raise Error("vote_for_peer error") except Exception as e: print(e.msg) logger.close(result)
def test_main(self): result = False logger.open("TestGover14.log", "TestGover14") try: if (not pause("ensure that node A and node B is in the nodes network and node A has more than 10000 ont.")): raise Error("pre-condition unsatisfied") (wallet_A_address, wallet_B_address, vote_price, node_B_puiblic_key, blocks_per_round, punish_ratio) = get_config() ''' # to ensure that the following operations are in the same round while(True): if getblockcount() % blocks_per_round <= 2: time.sleep(1) continue else: break ''' # step 1 wallet A vote for node B (result, response) = vote_for_peer(wallet_A_address, ["03e05d01e5df2c85e6a9a5526c70d080b6c7dce0fa7c66f8489c18b8569dc269dc"], ["190000"]) print (response) #if not result: # raise Error("vote_for_peer error") # step 1 wallet A vote for node B (result, response) = vote_for_peer(wallet_A_address, ["03e05d01e5df2c85e6a9a5526c70d080b6c7dce0fa7c66f8489c18b8569dc269dc"], ["10000"]) print (response) #if not result: # raise Error("vote_for_peer error") except Exception as e: print(e.msg) logger.close(result)
def test_12_consensus(self): result = False logger.open("12_consensus.log", "12_consensus") storage_key = ByteToHex(b'Test Key 12') storage_value = ByteToHex(b'Test Value 12') try: for i in range(1, 4): self.init_bft_node(i) time.sleep(30) #A节点是Admin节点 (result, response) = init_admin(self.m_contract_addr, Config.ontID_A) if not result: raise Error("init_admin error...") (result, response) = bind_role_function(self.m_contract_addr, Config.ontID_A, Config.roleA_hex, ["auth_put"]) if not result: raise Error("bind_role_function error...") (result, response) = invoke_function(self.m_contract_addr, "auth_put", Config.ontID_B, "1", argvs=[{ "type": "bytearray", "value": storage_key }, { "type": "bytearray", "value": storage_value }]) if not result: raise Error("invoke_function put error...") (result, response) = invoke_function(self.m_contract_addr, "get", Config.ontID_B, "1", argvs=[{ "type": "bytearray", "value": storage_key }]) if response["result"]["Result"] != '': result = False raise Error("invoke_function get error...") except Exception as e: print(e.msg) result = False logger.close(result)
def test_38_post_raw_tx(self): rawtxdata = self.m_signed_txhash_right action = "sendrawtransaction" version = "" logger.open("restful/38_post_raw_tx.log", "38_post_raw_tx") (result, response) = RestfulApi().postrawtx(rawtxdata, action, version) logger.close(result)
def test_41_post_raw_tx(self): rawtxdata = "" action = "sendrawtransaction" version = "1.0.0" logger.open("restful/41_post_raw_tx.log", "41_post_raw_tx") (result, response) = RestfulApi().postrawtx(rawtxdata, action, version) logger.close(not result)
def test_40_post_raw_tx(self): rawtxdata = self.m_signed_txhash_wrong action = "sendrawtransaction" version = "1.0.0" logger.open("restful/40_post_raw_tx.log", "40_post_raw_tx") (result, response) = RestfulApi().postrawtx(rawtxdata, action, version) logger.close(not result)
def setUp(self): logger.open("test_restful/" + 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) time.sleep(10)
def test_main(self): result = False logger.open("TestGover2.log", "TestGover2") try: if (not pause( "ensure that node A is not in the nodes network and node B is in the nodes network and node A has more than 10000 ont." )): raise Error("pre-condition unsatisfied") (wallet_A_address, wallet_B_address, vote_price, node_B_puiblic_key, blocks_per_round, punish_ratio) = get_config() block_count = getblockcount() # to ensure that the following operations are in the same round ''' while(True): if getblockcount() % blocks_per_round <= 2: time.sleep(5) continue else: break # step 1 wallet A vote for node B (result, response) = vote_for_peer(wallet_A_address, [node_B_puiblic_key], [vote_price]) print (response) #if not result: # raise Error("vote error") # step 2 wallet A unvote in the same round (result, response) = unvote_for_peer(wallet_A_address, [node_B_puiblic_key], [vote_price]) #if not result: # raise Error("vote error") # wait until the next two blocks print (getblockcount(), block_count) while(True): if getblockcount() - block_count == 0: print (getblockcount(), block_count) time.sleep(5) else: break # step 3 wallet A withdraw ont (result, response) = withdraw_ont(wallet_A_address, [node_B_puiblic_key], [vote_price]) #if not result: # raise Error("vote error") ''' # this should be failed (result, response) = unvote_for_peer(wallet_A_address, [node_B_puiblic_key], ["10"]) (result, response) = withdraw_ont(wallet_A_address, [node_B_puiblic_key], ["10"]) #if not result: # raise Error("vote error") except Exception as e: print(e.msg) logger.close(result)
def test_53_get_contract_state(self): (contractaddr_right, txhash_right) = deploy_contract_full("tasks/A.neo", "name", "desc", 0) script_hash = contractaddr_right logger.open("restful/53_get_contract_state.log", "53_get_contract_state") (result, response) = RestfulApi().getcontract(script_hash) logger.close(not result)
def test_onto_1(self): result = False logger.open("test_onto_1.log", "test_onto_1") try: (result, response) = init_admin(self.CONTRACT_ADDRESS_CORRECT, self.ontID_A) except Exception as e: print(e.msg) logger.close(result)
def test_gov_11(self): result = False logger.open("TestGover11.log", "TestGover11") try: (wallet_A_address, wallet_B_address, vote_price, node_B_puiblic_key, blocks_per_round, punish_ratio) = get_config() vote_price = "20000" # step 1 wallet A vote for node B (result, response) = vote_for_peer_index(wallet_A_address, [node_B_puiblic_key], [vote_price]) print(response) #if not result: # raise Error("vote_for_peer error") # step 2 wait until the second round invoke_function_consensus(Config.NODES[0]["pubkey"]) time.sleep(5) (result, response) = quit_node_index(node_B_puiblic_key, wallet_B_address, 7) # step 3 wallet A withdraw ont in the third round invoke_function_consensus(Config.NODES[0]["pubkey"]) time.sleep(5) (result, response) = withdraw_ont_index(wallet_A_address, [node_B_puiblic_key], [vote_price]) #if not result: # raise Error("withdraw_ont error") (result, response) = unvote_for_peer_index(wallet_A_address, [node_B_puiblic_key], [vote_price]) # step 3 wallet A withdraw ont in the fifth round invoke_function_consensus(Config.NODES[0]["pubkey"]) time.sleep(5) invoke_function_consensus(Config.NODES[0]["pubkey"]) time.sleep(5) (result, response) = withdraw_ont_index(wallet_A_address, [node_B_puiblic_key], [vote_price]) #if not result: # raise Error("withdraw_ont error") # this should be failed (result, response) = withdraw_ont(wallet_A_address, [node_B_puiblic_key], ["1"]) #if not result: # raise Error("withdraw_ont error") except Exception as e: print(e.msg) logger.close(result)
def test_gov_14(self): result = False logger.open("TestGover14.log", "TestGover14") try: (wallet_A_address, wallet_B_address, vote_price, node_B_puiblic_key, blocks_per_round, punish_ratio) = get_config() invoke_function_update("updateGlobalParam", "2000000000", "10000", "32", "1", "50", "50", "50", "50") # step 1 wallet A vote for node B (result, response) = vote_for_peer_index(wallet_A_address, [node_B_puiblic_key], [vote_price]) print(response) #if not result: # raise Error("vote_for_peer error") # step 2 wait until the second round invoke_function_consensus(Config.NODES[0]["pubkey"]) time.sleep(5) (result, response) = black_node([node_B_puiblic_key]) # step 3 wallet A withdraw ont in the third round # should failed (result, response) = withdraw_ont_index(wallet_A_address, [node_B_puiblic_key], [vote_price]) #if not result: # raise Error("withdraw_ont error") (result, response) = unvote_for_peer_index(wallet_A_address, [node_B_puiblic_key], [vote_price]) # step 4 wallet A withdraw ont in the forth round invoke_function_consensus(Config.NODES[0]["pubkey"]) time.sleep(5) (result, response) = withdraw_ont_index(wallet_A_address, [node_B_puiblic_key], [str(int(punish_ratio * 3000))]) #if not result: # raise Error("withdraw_ont error") # this should be failed (result, response) = withdraw_ont_index(wallet_A_address, [node_B_puiblic_key], ["1"]) #if not result: # raise Error("withdraw_ont error") except Exception as e: print(e.msg) logger.close(result)
def test_main(self): result = False logger.open("TestGover1.log", "TestGover1") try: if (not pause( "ensure that node A is not in the nodes network and node B is in the nodes network and node A has more than 10000 ont." )): raise Error("pre-condition unsatisfied") (wallet_A_address, wallet_B_address, vote_price, node_B_puiblic_key, blocks_per_round, punish_ratio) = get_config() block_count = getblockcount() # step 1 before vote get balance of wallet A B balance_of_wallet_A_1 = getbalance_ont(wallet_A_address) balance_of_wallet_B_1 = getbalance_ont(wallet_B_address) print("A:", balance_of_wallet_A_1) print("B:", balance_of_wallet_B_1) # step 2 wallet A vote for node B (result, response) = vote_for_peer(wallet_A_address, [node_B_puiblic_key], [vote_price]) #if not result: # raise Error("vote error") # wait until the next two blocks while (True): if getblockcount() - block_count <= 1: print(getblockcount(), block_count) time.sleep(5) else: break # step 3 after vote get balance of wallet A B balance_of_wallet_A_2 = getbalance_ont(wallet_A_address) balance_of_wallet_B_2 = getbalance_ont(wallet_B_address) print("2A:", balance_of_wallet_A_2) print("2B:", balance_of_wallet_B_2) # step 4 compare if balance_of_wallet_B_1 != balance_of_wallet_B_2: raise Error("balance of wallte B changed.") if balance_of_wallet_A_1 - balance_of_wallet_A_2 != int( vote_price): raise Error("the decrease of balance of wallet A is not %s." % vote_price) except Exception as e: print(e.msg) logger.close(result)
def test_01_get_gen_blk_time(self): stop_all_nodes() start_nodes([0, 1, 2, 3, 4, 5, 6], Config.DEFAULT_NODE_ARGS, True, True, config="config-dbft-1.json") time.sleep(10) logger.open("restful/01_get_gen_blk_time.log", "01_get_gen_blk_time") (result, response) = RestfulApi().getgenerateblocktime() logger.close(result)
def setUp(self): logger.open("test_consensus/" + self._testMethodName + ".log", self._testMethodName) 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(0, 7): API.native().regid_with_publickey(i) API.native().init_ont_ong()
def test_main(self): result = False logger.open("TestGover12.log", "TestGover12") try: if (not pause( "ensure that node A and node B is in the nodes network and node A has more than 10000 ont." )): raise Error("pre-condition unsatisfied") (wallet_A_address, wallet_B_address, vote_price, node_B_puiblic_key, blocks_per_round, punish_ratio) = get_config() ''' # to ensure that the following operations are in the same round while(True): if getblockcount() % blocks_per_round <= 2: time.sleep(1) continue else: break ''' # step 1 wallet A vote for node B (result, response) = vote_for_peer(wallet_A_address, [node_B_puiblic_key], [vote_price]) print(response) #if not result: # raise Error("vote error") # step 2 black node b if (not pause("black node over?")): pass #if not result: # raise Error("black_node error") # step 3 withdraw ont (result, response) = withdraw_ont(wallet_A_address, [node_B_puiblic_key], [vote_price]) #if not result: # raise Error("withdraw_ont error") # this should be failed (result, response) = withdraw_ont(wallet_A_address, [node_B_puiblic_key], ["1"]) #if not result: # raise Error("withdraw_ont error") except Exception as e: print(e.msg) logger.close(result)
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])
def test_75_no_url(self): request = { "TYPE": "restful", "REQUEST": { "api": "" }, "RESPONSE": { "Error": 0, } } task = Task(name="75_no_url", ijson=request) logger.open("restful/75_no_url.log", "75_no_url") (result, response) = run_single_task(task) logger.close(not result)
def test_74_get_conn_count1(self): request = { "TYPE": "restful", "REQUEST": { "api": "/api/v1/get_conn_count1" }, "RESPONSE": { "Error": 0, } } task = Task(name="74_get_conn_count1", ijson=request) logger.open("restful/74_get_conn_count1.log", "74_get_conn_count1") (result, response) = run_single_task(task) logger.close(not result)