def get_no_candidate_list(self): ''' 获取未被质押的节点ID列表 :return: ''' url = CommonMethod.link_list(self) platon_ppos = Ppos(url, self.address, self.chainid) node_info = get_node_info(self.node_yml_path) self.rpc_list, enode_list, nodeid_list, ip_list, port_list = node_info.get( 'nocollusion') no_candidate_list = [] for index in range(len(nodeid_list)): nodeid = nodeid_list[index] result = platon_ppos.getCandidateInfo(nodeid) flag = result['Status'] if not flag: no_candidate_list.append(nodeid) if no_candidate_list: node_list_length = len(no_candidate_list) index = random.randint(0, node_list_length - 1) nodeId = no_candidate_list[index] return nodeId else: CommonMethod.start_init(self) # self.rpc_list, enode_list, nodeid_list, ip_list, port_list = node_info.get ('nocollusion') return nodeid_list[0]
def test_token_transactions(self): node_info = get_node_info(conf.TWENTY_FIVENODE_YML) self.rpc_list, enode_list, nodeid_list, ip_list, port_list = node_info.get( 'collusion') from_address = Web3.toChecksumAddress(conf.ADDRESS) to_address = Web3.toChecksumAddress( self.ppos_link(self.rpc_list).web3.personal.newAccount(self.pwd)) send_data = self.transfer_parameters(to_address, from_address) self.platon_ppos.eth.sendTransaction(send_data) assert self.platon_dpos1.eth.getBalance( to_address) == self.w3_list[0].toWei(100000, 'ether')
def test_token_loukup(self): #查看初始化时锁仓余额 file = conf.GENESIS_TMP_OTHER genesis_dict = LoadFile(file).get_data() FOUNDATION = genesis_dict['alloc'][conf.FOUNDATIONADDRESS] FOUNDATIONLOCKUP = self.platon_dpos1.eth.getBalance( conf.FOUNDATIONLOCKUPADDRESS) node_info = get_node_info(conf.PPOS25NODE_YML) self.rpc_list, enode_list, nodeid_list, ip_list, port_list = node_info.get( 'collusion') FOUNDATIONTOTAL = conf.TOKENTOTAL * 0.01 assert FOUNDATIONTOTAL == (FOUNDATION + FOUNDATIONLOCKUP)
def read_out_nodeId(self, code): """ 读取节点id列表 :param code: 共识节点或者非共识节点标识 :return: """ node_info = get_node_info(self.node_yml_path) self.rpc_list, enode_list, nodeid_list, ip_list, port_list = node_info.get( code) node_list_length = len(nodeid_list) index = random.randint(0, node_list_length - 1) nodeId = nodeid_list[index] return nodeId
def View_available_nodes(self): url = CommonMethod.link_list(self) platon_ppos = Ppos(url, self.address, self.chainid) node_info = get_node_info(self.node_yml_path) self.rpc_list, enode_list, nodeid_list, ip_list, port_list = node_info.get( 'nocollusion') candidateinfo = platon_ppos.getCandidateList() candidateinfo = candidateinfo.get('Data') candidate_list = [] for nodeid in candidateinfo: candidate_list.append(nodeid.get('NodeId')) if set(nodeid_list) <= set(candidate_list): CommonMethod.start_init(self)
def ppos_link(self, url=None, address=conf.ADDRESS, privatekey=conf.PRIVATE_KEY): if url is None: node_info = get_node_info(conf.TWENTY_FIVENODE_YML) self.rpc_list, enode_list, nodeid_list, ip_list, port_list = node_info.get( 'collusion') rpc_list_length = len(self.rpc_list) - 1 index = random.randint(0, rpc_list_length) url = self.rpc_list[index] self.platon_ppos = Ppos(url, address=address, chainid=101, privatekey=privatekey) return self.platon_ppos
def link_list(self): ''' 获取随机一个可以连接正常节点url :return: ''' rpc_lastlist = [] node_info = get_node_info(self.node_yml_path) self.rpc_list, enode_list, self.nodeid_list, ip_list, port_list = node_info.get( 'collusion') for i in self.rpc_list: self.web3 = connect_web3(i) if self.web3.isConnected(): rpc_lastlist.append(i) if rpc_lastlist: #log.info("目前可连接节点列表:{}".format(rpc_lastlist)) index = random.randint(0, len(rpc_lastlist) - 1) url = rpc_lastlist[index] log.info("当前连接节点:{}".format(url)) return url else: log.info("无可用节点")
class TestConsensus: node_yml = conf.NODE_YML consensus_list, _ = get_node_list(node_yml) f = get_f(consensus_list) n = len(consensus_list) url_list, enode_list, nodeid_list, ip_list, _ = get_node_info( node_yml)["collusion"] genesis_path = conf.GENESIS_TMP auto = AutoDeployPlaton() cbft_path = conf.CBFT_TMP cbft_template = conf.CBFT_TEMPLATE def teardown_class(self): self.auto.start_all_node(self.node_yml) def get_cbft_json_data(self, period, duration): with open(self.cbft_template, 'r', encoding='utf-8') as f: res = json.loads(f.read()) res['period'] = period res['duration'] = duration with open(self.cbft_path, 'w', encoding='utf-8') as b: cbft_json = json.dumps(res) b.write(cbft_json) @allure.title("每个节点在窗口期正常出块") def test_block_out_of_each_node_window(self): """ 用例id:73 测试 N 个节点每个窗口期都在出块 """ log.info("更新cbft文件") self.get_cbft_json_data(period=1, duration=10) auto = AutoDeployPlaton(cbft=self.cbft_path) auto.start_all_node(self.node_yml) log.info("跟所有节点建立连接") w3_list = [connect_web3(url) for url in self.url_list] w3 = w3_list[0] start_block = w3.eth.blockNumber time.sleep(self.n * 10 + 5) block_number = w3.eth.blockNumber if block_number > 0: log.info("正在出块,块高:{}".format(block_number)) node_id_dict = {} log.info("获取1至{}块的nodeID".format(block_number)) for block in range(start_block, block_number + 1): node_id = get_pub_key(self.url_list[0], block) if node_id not in node_id_dict.keys(): node_id_dict[node_id] = 1 else: node_id_dict[node_id] += 1 log.info("nodeID对应的出块数{}".format(node_id_dict)) assert self.n == len(node_id_dict), "出块节点数少于共识节点数" for k, v in node_id_dict.items(): assert 0 <= v <= 20, "节点{}出块周期约为10个块,实际为{}".format(k, v) @allure.title("cbft.json配置period{period}-{duration}") @pytest.mark.parametrize('period,duration', [(1, 10), (3, 30), (5, 50), (10, 100), (0, 10)]) def test_block_time_period(self, period, duration): ''' 用例id 1,2,3,4,5 测试period的不同值,观察查看时间 根据5种场景,分别出块时间约为1,3,5,10,1s ''' log.info("更新cbft.json") self.get_cbft_json_data(period, duration) auto = AutoDeployPlaton(cbft=self.cbft_path) auto.start_all_node(self.node_yml) time.sleep(duration + 5) log.info("跟所有节点建立连接") w3_list = [connect_web3(url) for url in self.url_list] w3 = w3_list[0] block_number = w3.eth.blockNumber assert block_number > 1, "没有正常出块" log.info(block_number) start_time = w3.eth.getBlock(1).get("timestamp") end_time = w3.eth.getBlock(block_number).get("timestamp") use_time = end_time - start_time average_time = int(use_time / (block_number - 1)) log.info("平均出块时间{}".format(average_time)) if period == 0: period = 1 deviation = int(period * 1000 * 0.5) assert period * 1000 - deviation < average_time < period * \ 1000 + deviation, "出块间隔过大或过小" @allure.title("cbft.json配置period{period}-{duration}-{delay_time}--{number}" ) @pytest.mark.parametrize('period,duration,delay_time,number', [(1, 10, 50, 30), (1, 20, 90, 70), (1, 30, 130, 90), (1, 50, 180, 140), (1, 100, 350, 250)]) def test_block_cycle_duration(self, period, duration, delay_time, number): ''' 用例id 6,7,8,9,10 测试duration的不同值,观察出块周期 根据5种场景,出块周期约为10,20,30,50,100 ''' self.get_cbft_json_data(period, duration) auto = AutoDeployPlaton(cbft=self.cbft_path) log.info("上传cbft文件成功") auto.start_all_node(self.node_yml) time.sleep(delay_time) log.info("跟所有节点建立连接") w3_list = [connect_web3(url) for url in self.url_list] w3 = w3_list[0] block_number = w3.eth.blockNumber if block_number > 0: log.info("正在出块,块高:{}".format(block_number)) if block_number < number: raise Exception("出块很慢,没达到预期{}".format(number)) node_id_dict = {} log.info("获取1至{}块的nodeID".format(number)) for block in range(1, number): node_id = get_pub_key(self.url_list[0], block) if node_id not in node_id_dict.keys(): node_id_dict[node_id] = [block] else: node_id_dict[node_id].append(block) log.info("获取到全部的nodeID对应的出块".format(node_id_dict)) log.info("由于第一组nodeID收集数据不全,从第二组开始收集统计,删除第一组") node_id_list = [] for node_id in node_id_dict.keys(): node_id_list.append(node_id) node_id_dict.pop(node_id_list[0]) log.info("统计出nodeID对应的出块ID{}".format(node_id_dict)) print(node_id_dict) print(node_id_list) if duration == 10: block_cycle_a = node_id_dict.get(node_id_list[1]) log.info("出块人A出块周期数:%s" % block_cycle_a) assert 7 <= len(block_cycle_a) <= 12, "出块周期预期在7到12,实际{}".format( len(block_cycle_a)) block_cycle_b = node_id_dict.get(node_id_list[2]) log.info("出块人B出块周期数:%s" % block_cycle_b) assert 7 <= len(block_cycle_b) <= 12, "出块周期预期在7到12,实际{}".format( len(block_cycle_b)) times_tamp_a = w3.eth.getBlock(block_cycle_a[-1]).get("timestamp") times_tamp_b = w3.eth.getBlock(block_cycle_b[-1]).get("timestamp") log.info("获取出块人B的最后一个块的时间戳%s" % times_tamp_b) assert 8000 < times_tamp_b - \ times_tamp_a < 12000, "预期出块周期为8到12s,实际为{}".format( times_tamp_b - times_tamp_a) log.info( "出块人B最后一个块出块时间-出块人A最后一个块出块时间 = 出块周期时间{}".format(times_tamp_b - times_tamp_a)) if duration == 20: block_cycle_a = node_id_dict.get(node_id_list[1]) log.info("出块人A出块周期数:%s" % block_cycle_a) assert 16 <= len(block_cycle_a) <= 23, "出块周期预期在16到23,实际{}".format( len(block_cycle_a)) block_cycle_b = node_id_dict.get(node_id_list[2]) log.info("出块人B出块周期数:%s" % block_cycle_b) assert 16 <= len(block_cycle_b) <= 23, "出块周期预期在16到23,实际{}".format( len(block_cycle_b)) times_tamp_a = w3.eth.getBlock(block_cycle_a[-1]).get("timestamp") times_tamp_b = w3.eth.getBlock(block_cycle_b[-1]).get("timestamp") log.info("获取出块人B的最后一个块的时间戳%s" % times_tamp_b) assert 16000 < times_tamp_b - times_tamp_a < 23000, "预期出块周期为16到23s,实际为{}".format( times_tamp_b - times_tamp_a) log.info( "出块人B最后一个块出块时间-出块人A最后一个块出块时间 = 出块周期时间{}".format(times_tamp_b - times_tamp_a)) if duration == 30: block_cycle_a = node_id_dict.get(node_id_list[1]) log.info("出块人A出块周期数:%s" % block_cycle_a) assert 26 <= len(block_cycle_a) <= 33, "出块周期预期在26到33,实际{}".format( len(block_cycle_a)) block_cycle_b = node_id_dict.get(node_id_list[2]) log.info("出块人B出块周期数:%s" % block_cycle_b) assert 26 <= len(block_cycle_b) <= 33, "出块周期预期在26到33,实际{}".format( len(block_cycle_b)) times_tamp_a = w3.eth.getBlock(block_cycle_a[-1]).get("timestamp") times_tamp_b = w3.eth.getBlock(block_cycle_b[-1]).get("timestamp") log.info("获取出块人B的最后一个块的时间戳%s" % times_tamp_b) assert 26000 < times_tamp_b - times_tamp_a < 33000, "预期出块周期为26到30s,实际为{}".format( times_tamp_b - times_tamp_a) log.info( "出块人B最后一个块出块时间-出块人A最后一个块出块时间 = 出块周期时间{}".format(times_tamp_b - times_tamp_a)) if duration == 50: block_cycle_a = node_id_dict.get(node_id_list[1]) log.info("出块人A出块周期数:%s" % block_cycle_a) assert 40 <= len(block_cycle_a) <= 60, "出块周期预期在40到60,实际{}".format( len(block_cycle_a)) block_cycle_b = node_id_dict.get(node_id_list[2]) log.info("出块人B出块周期数:%s" % block_cycle_b) assert 40 <= len(block_cycle_b) <= 60, "出块周期预期在40到60,实际{}".format( len(block_cycle_b)) times_tamp_a = w3.eth.getBlock(block_cycle_a[-1]).get("timestamp") times_tamp_b = w3.eth.getBlock(block_cycle_b[-1]).get("timestamp") log.info("获取出块人B的最后一个块的时间戳%s" % times_tamp_b) assert 4000 < times_tamp_b - times_tamp_a < 60000, "预期出块周期为40到60s,实际为{}".format( times_tamp_b - times_tamp_a) log.info( "出块人B最后一个块出块时间-出块人A最后一个块出块时间 = 出块周期时间{}".format(times_tamp_b - times_tamp_a)) if duration == 100: block_cycle_a = node_id_dict.get(node_id_list[1]) log.info("出块人A出块周期数:%s" % block_cycle_a) assert 90 <= len( block_cycle_a) <= 110, "出块周期预期在90到110,实际{}".format( len(block_cycle_a)) block_cycle_b = node_id_dict.get(node_id_list[2]) log.info("出块人B出块周期数:%s" % block_cycle_b) assert 90 <= len( block_cycle_b) <= 110, "出块周期预期在90到110,实际{}".format( len(block_cycle_b)) times_tamp_a = w3.eth.getBlock(block_cycle_a[-1]).get("timestamp") times_tamp_b = w3.eth.getBlock(block_cycle_b[-1]).get("timestamp") log.info("获取出块人B的最后一个块的时间戳%s" % times_tamp_b) assert 90000 < times_tamp_b - times_tamp_a < 110000, "预期出块周期为99到110s,实际为{}".format( times_tamp_b - times_tamp_a) log.info( "出块人B最后一个块出块时间-出块人A最后一个块出块时间 = 出块周期时间{}".format(times_tamp_b - times_tamp_a)) @allure.title("重启节点后查看旧块交易,钱包余额") def test_kill_process_observation_block_data(self): ''' 用例id 30,31,32,33 测试kill进程后,重启查看块高持续增长 测试kill进程后,重启查看旧块转账,合约信息不变 测试kill进程后,钱包余额不变 ''' log.info("部署节点") self.auto.start_all_node(self.node_yml) log.info("启动会等待60s出块") time.sleep(10) log.info("跟所有节点建立连接") w3_list = [connect_web3(url) for url in self.url_list] w3 = w3_list[0] number_before = w3.eth.blockNumber if number_before == 0: raise Exception("起服务但未出块") log.info("块高为:{}".format(number_before)) log.info("发起转账交易") t_hash = self.transaction(w3) result, number, result_block, hash_list = self.check_block_information( w3, t_hash) log.info("发起合约交易") contract_address, resp, contract_number = self.deploy_contract() log.info("kill 所有节点") self.auto.kill_of_yaml(self.node_yml) time.sleep(2) log.info("重启platon服务") self.auto.start_all_node(self.node_yml, is_need_init=False) log.info("重启25节点后,延迟30s") time.sleep(30) w3_list = [connect_web3(url) for url in self.url_list] w3 = w3_list[0] number_after = w3.eth.blockNumber assert number_after >= number_before, "块高未有增长" balance = w3.eth.getBalance(w3.eth.accounts[1]) assert balance == 100000, "kill进程重启后余额发生变化,余额为:{}".format(balance) log.info("查看重启前的{}区块转账信息".format(number)) t_hash_list = (w3.eth.getBlock(number).get("transactions")) log.info("查看重启前的{}区块合约信息".format(contract_number)) c_hash_list = (w3.eth.getBlock(contract_number).get("transactions")) log.info("通过transactions字段得到的交易哈希列表:{}".format(hash_list)) assert t_hash in t_hash_list, "kill进程重启后转账交易丢失" c_hash = HexBytes(resp) assert c_hash in c_hash_list, "kill进程重启后合约交易丢失" contract_address_after = w3.eth.waitForTransactionReceipt(resp).get( 'contractAddress') assert contract_address == contract_address_after, "kill进程后,合约地址发生改变" def check_block_information(self, w3, hash): transaction_hash = HexBytes(hash).hex() result = w3.eth.waitForTransactionReceipt(transaction_hash) number = result.get("blockNumber") result_block = w3.eth.getBlock(number) hash_list = result_block.get("transactions") return result, number, result_block, hash_list def transaction(self, w3, value=100000): from_address = w3.toChecksumAddress(w3.eth.accounts[0]) to_address = w3.toChecksumAddress(w3.personal.newAccount('88888888')) log.info("解锁账号") w3.personal.unlockAccount(from_address, '88888888', 666666) params = { 'to': to_address, 'from': from_address, 'gas': 91000000, 'gasPrice': 9000000000, 'value': value } t_hash = w3.eth.sendTransaction(params) return t_hash def deploy_contract(self): consensus_list, _ = get_node_list(self.node_yml) url = consensus_list[0]['url'] wt = PlatonContractTransaction(url) addrress = wt.w3.toChecksumAddress(conf.ADDRESS) wt.w3.personal.unlockAccount(addrress, conf.PASSWORD, 99999999) log.info("部署合约") resp = wt.contract_deploy( get_byte_code(abspath('./data/contract/sum.wasm')), get_abi_bytes(abspath('./data/contract/sum.cpp.abi.json')), addrress) log.info("获取合约交易信息") result = wt.eth.waitForTransactionReceipt(resp) contract_address = result['contractAddress'] contract_number = result['blockNumber'] return contract_address, resp, contract_number
class TestUndelegate(): node_yml_path = conf.NODE_YML node_info = get_node_info(node_yml_path) rpc_list, enode_list, nodeid_list, ip_list, port_list = node_info.get( 'collusion') rpc_list2, enode_list2, nodeid_list2, ip_list2, port_list2 = node_info.get( 'nocollusion') address = Web3.toChecksumAddress(conf.ADDRESS) privatekey = conf.PRIVATE_KEY account_list = conf.account_list privatekey_list = conf.privatekey_list externalId = "1111111111" nodeName = "platon" website = "https://www.test.network" details = "supper node" programVersion = 1792 illegal_nodeID = conf.illegal_nodeID genesis_path = conf.GENESIS_TMP """替换config.json""" get_config_data() config_json_path = conf.PLATON_CONFIG_PATH config_dict = LoadFile(config_json_path).get_data() amount_delegate = Web3.fromWei( int(config_dict['EconomicModel']['Staking']['MinimumThreshold']), 'ether') amount = Web3.fromWei( int(config_dict['EconomicModel']['Staking']['StakeThreshold']), 'ether') def setup_class(self): self.auto = AutoDeployPlaton() self.auto.start_all_node(self.node_yml_path) self.genesis_dict = LoadFile(self.genesis_path).get_data() self.chainid = int(self.genesis_dict["config"]["chainId"]) self.ppos_link = Ppos(self.rpc_list[0], self.address, self.chainid) self.w3_list = [connect_web3(url) for url in self.rpc_list] """用新的钱包地址和未质押过的节点id封装对象""" self.ppos_noconsensus_1 = Ppos(self.rpc_list[0], self.account_list[0], self.chainid, privatekey=self.privatekey_list[0]) self.ppos_noconsensus_2 = Ppos(self.rpc_list[0], self.account_list[1], self.chainid, privatekey=self.privatekey_list[1]) self.ppos_noconsensus_3 = Ppos(self.rpc_list[0], self.account_list[2], self.chainid, privatekey=self.privatekey_list[2]) self.ppos_noconsensus_4 = Ppos(self.rpc_list[0], self.account_list[3], self.chainid, privatekey=self.privatekey_list[3]) self.ppos_noconsensus_5 = Ppos(self.rpc_list[0], self.account_list[4], self.chainid, privatekey=self.privatekey_list[4]) self.ppos_noconsensus_6 = Ppos(self.rpc_list[0], self.account_list[5], self.chainid, privatekey=self.privatekey_list[5]) self.eth = Eth(self.w3_list[0]) def transaction(self, w3, from_address, to_address=None, value=1000000000000000000000000000000000, gas=91000000, gasPrice=9000000000, pwd=conf.PASSWORD): """" 转账公共方法 """ personal = Personal(w3) personal.unlockAccount(from_address, pwd, 666666) params = { 'to': to_address, 'from': from_address, 'gas': gas, 'gasPrice': gasPrice, 'value': value } tx_hash = w3.eth.sendTransaction(params) result = w3.eth.waitForTransactionReceipt(HexBytes(tx_hash).hex()) return result def getCandidateList(self): """ 获取实时验证人的nodeID list """ msg = self.ppos_noconsensus_1.getCandidateList() recive_list = msg.get("Data") nodeid_list = [] if recive_list is None: return recive_list else: for node_info in recive_list: nodeid_list.append(node_info.get("NodeId")) return nodeid_list ##############################赎回#################################################### @allure.title("委托人未达到锁定期申请赎回") @pytest.mark.P0 def test_unDelegate_part(self): """ 用例id 106 申请赎回委托 用例id 111 委托人未达到锁定期申请赎回 申请部分赎回 """ log.info("转账到钱包3") self.transaction(self.w3_list[0], self.address, to_address=self.account_list[2]) log.info("转账到钱包4") self.transaction(self.w3_list[0], self.address, to_address=self.account_list[3]) msg = self.ppos_noconsensus_1.getCandidateInfo(self.nodeid_list2[2]) if msg['Data'] == "": log.info("质押节点3:{}成为验证节点".format(self.nodeid_list2[2])) self.ppos_noconsensus_3.createStaking(0, self.account_list[2], self.nodeid_list2[2], self.externalId, self.nodeName, self.website, self.details, self.amount, self.programVersion) log.info("钱包4 {}委托到3 {}".format(self.account_list[3], self.account_list[2])) value = 100 self.ppos_noconsensus_4.delegate(0, self.nodeid_list2[2], value) log.info("查询当前节点质押信息") msg = self.ppos_noconsensus_3.getCandidateInfo(self.nodeid_list2[2]) stakingBlockNum = msg["Data"]["StakingBlockNum"] log.info("发起质押的区高{}".format(stakingBlockNum)) delegate_value = 20 self.ppos_noconsensus_4.unDelegate(stakingBlockNum, self.nodeid_list2[2], delegate_value) log.info("查询钱包{}的委托信息".format(self.account_list[3])) msg = self.ppos_noconsensus_4.getDelegateInfo(stakingBlockNum, self.account_list[3], self.nodeid_list2[2]) print(msg) data = msg["Data"] """不清楚msg["Data"]对应value是str类型,需要再转字典""" data = json.loads(data) print(data) assert Web3.toChecksumAddress(data["Addr"]) == self.account_list[3] assert data["NodeId"] == self.nodeid_list2[2] print(data["ReleasedHes"]) value = value - delegate_value result_value = Web3.toWei(value, "ether") assert data["ReleasedHes"] == result_value @allure.title("大于委托金额赎回") @pytest.mark.P0 def test_unDelegate_iff(self): """ 验证 大于委托金额赎回 """ msg = self.ppos_noconsensus_1.getCandidateInfo(self.nodeid_list2[2]) if msg['Data'] == "": log.info("质押节点3成为验证节点") self.ppos_noconsensus_3.createStaking(0, self.account_list[2], self.nodeid_list2[2], self.externalId, self.nodeName, self.website, self.details, self.amount, self.programVersion) log.info("钱包4 委托到3 {}") value = 100 self.ppos_noconsensus_4.delegate(0, self.nodeid_list2[2], value) msg = self.ppos_noconsensus_3.getCandidateInfo(self.nodeid_list2[2]) stakingBlockNum = msg["Data"]["StakingBlockNum"] msg = self.ppos_noconsensus_4.getDelegateInfo(stakingBlockNum, self.account_list[3], self.nodeid_list2[2]) data = msg["Data"] """不清楚msg["Data"]对应value是str类型,需要再转字典""" data = json.loads(data) releasedHes = data["ReleasedHes"] releasedHes = Web3.fromWei(releasedHes, 'ether') log.info("委托钱包可赎回的金额单位eth:{}".format(releasedHes)) delegate_value = releasedHes + 20 msg = self.ppos_noconsensus_4.unDelegate(stakingBlockNum, self.nodeid_list2[2], delegate_value) assert msg["Status"] == False err_msg = "withdrewDelegate err: The von of delegate is not enough" assert err_msg in msg["ErrMsg"] @allure.title("赎回全部委托的金额与赎回金额为0") @pytest.mark.P1 def test_unDelegate_all(self): """ 验证 赎回全部委托的金额 验证 赎回金额为0 """ log.info("转账到钱包1") self.transaction(self.w3_list[0], self.address, to_address=self.account_list[0]) log.info("转账到钱包2") self.transaction(self.w3_list[0], self.address, to_address=self.account_list[1]) log.info("节点1质押成为验证人") self.ppos_noconsensus_1.createStaking(0, self.account_list[0], self.nodeid_list2[0], self.externalId, self.nodeName, self.website, self.details, self.amount, self.programVersion) msg = self.ppos_noconsensus_1.getCandidateInfo(self.nodeid_list2[0]) stakingBlockNum = msg["Data"]["StakingBlockNum"] log.info("查询节点质押信息,质押块高{}".format(stakingBlockNum)) log.info("钱包2进行委托") value = 80 self.ppos_noconsensus_2.delegate(0, self.nodeid_list2[0], value) msg = self.ppos_noconsensus_2.getDelegateInfo(stakingBlockNum, self.account_list[1], self.nodeid_list2[0]) data = msg["Data"] """不清楚msg["Data"]对应value是str类型,需要再转字典""" data = json.loads(data) log.info(data) releasedHes = data["ReleasedHes"] releasedHes = Web3.fromWei(releasedHes, 'ether') log.info("委托钱包可赎回的金额单位eth:{}".format(releasedHes)) account_before = self.eth.getBalance(self.account_list[1]) msg = self.ppos_noconsensus_2.unDelegate(stakingBlockNum, self.nodeid_list2[0], releasedHes) assert msg["Status"] == True account_after = self.eth.getBalance(self.account_list[1]) result_value = account_after - account_before ##为什么会赎回多那么多钱?1000000000000159999910972325109760 assert account_before + data["ReleasedHes"] > account_after assert 70 < Web3.fromWei(result_value, "ether") < releasedHes, "赎回的金额减去gas应在这范围" log.info("全部委托金额赎回后,查询委托金额".format(account_after)) msg = self.ppos_noconsensus_2.getDelegateInfo(stakingBlockNum, self.account_list[1], self.nodeid_list2[0]) log.info(msg) """如果全部金额赎回,再查getDelegateInfo返回数据为空""" assert msg["Status"] == False assert msg["ErrMsg"] == "Delegate info is not found" @allure.title("多次委托,多次赎回") @pytest.mark.P1 def test_multiple_delegate_undelegate(self): """ 验证多次委托,多次赎回 """ log.info("转账到钱包5") self.transaction(self.w3_list[0], self.address, to_address=self.account_list[4]) log.info("转账到钱包6") self.transaction(self.w3_list[0], self.address, to_address=self.account_list[5]) msg = self.ppos_noconsensus_5.getCandidateInfo(self.nodeid_list2[4]) if msg['Data'] == "": log.info("质押节点5成为验证节点") self.ppos_noconsensus_5.createStaking(0, self.account_list[4], self.nodeid_list2[4], self.externalId, self.nodeName, self.website, self.details, self.amount, self.programVersion) msg = self.ppos_noconsensus_5.getCandidateInfo(self.nodeid_list2[4]) stakingBlockNum = msg["Data"]["StakingBlockNum"] log.info("查询节点质押信息回去质押块高{}".format(stakingBlockNum)) value_list = [10, 11, 12, 13, 14, 15, 16, 17, 18] for value in value_list: log.info("钱包6 委托金额{}".format(value)) self.ppos_noconsensus_6.delegate(0, self.nodeid_list2[4], value) msg = self.ppos_noconsensus_6.getDelegateInfo(stakingBlockNum, self.account_list[5], self.nodeid_list2[4]) log.info(msg) data = json.loads(msg["Data"]) releasedHes = Web3.fromWei(data["ReleasedHes"], 'ether') log.info("查询委托的金额{}eth".format(releasedHes)) delegate_value = 0 for i in value_list: delegate_value = i + delegate_value assert delegate_value == releasedHes, "委托的金额与查询到的金额不一致" for value in value_list: log.info("赎回的金额:{}eth".format(value)) log.info("钱包6进行赎回") self.ppos_noconsensus_6.unDelegate(stakingBlockNum, self.nodeid_list2[4], value) log.info("赎回委托金额后查询委托信息") msg = self.ppos_noconsensus_6.getDelegateInfo(stakingBlockNum, self.account_list[5], self.nodeid_list2[4]) """如果全部金额赎回,再查getDelegateInfo返回数据为空""" log.info(msg)
import allure import pytest from common import log from deploy.deploy import AutoDeployPlaton from common.connect import connect_web3 from conf import setting as conf from common.load_file import get_f, get_node_info, get_node_list node_yml = conf.NODE_YML collusion_list, _ = get_node_list(node_yml) f = int(get_f(collusion_list)) n = len(collusion_list) auto = AutoDeployPlaton() url_list, enode_list, nodeid_list, ip_list, _ = get_node_info( node_yml)["collusion"] genesis_file = conf.GENESIS_TMP static_node_file = conf.STATIC_NODE_FILE def teardown_function(): log.info("关闭所有节点") auto.kill_of_yaml(node_yml) def teardown_module(): auto.start_all_node(node_yml) @allure.title("正常启动所有节点") def test_start_all_node():
class TestDelegate(): node_yml_path = conf.NODE_YML node_info = get_node_info(node_yml_path) rpc_list, enode_list, nodeid_list, ip_list, port_list = node_info.get( 'collusion') rpc_list2, enode_list2, nodeid_list2, ip_list2, port_list2 = node_info.get( 'nocollusion') address = Web3.toChecksumAddress(conf.ADDRESS) privatekey = conf.PRIVATE_KEY account_list = conf.account_list privatekey_list = conf.privatekey_list externalId = "1111111111" nodeName = "platon" website = "https://www.test.network" details = "supper node" programVersion = 1792 illegal_nodeID = conf.illegal_nodeID genesis_path = conf.GENESIS_TMP """替换config.json""" get_config_data() config_json_path = conf.PLATON_CONFIG_PATH config_dict = LoadFile(config_json_path).get_data() amount_delegate = Web3.fromWei( int(config_dict['EconomicModel']['Staking']['MinimumThreshold']), 'ether') amount = Web3.fromWei( int(config_dict['EconomicModel']['Staking']['StakeThreshold']), 'ether') def setup_class(self): self.auto = AutoDeployPlaton() self.auto.start_all_node(self.node_yml_path) self.genesis_dict = LoadFile(self.genesis_path).get_data() self.chainid = int(self.genesis_dict["config"]["chainId"]) self.ppos_link = Ppos( self.rpc_list[0],self.address,self.chainid) self.w3_list = [connect_web3(url) for url in self.rpc_list] """用新的钱包地址和未质押过的节点id封装对象""" self.ppos_noconsensus_1 = Ppos(self.rpc_list[0], self.account_list[0],self.chainid,privatekey=self.privatekey_list[0]) self.ppos_noconsensus_2 = Ppos(self.rpc_list[0], self.account_list[1],self.chainid,privatekey=self.privatekey_list[1]) self.ppos_noconsensus_3 = Ppos(self.rpc_list[0], self.account_list[2],self.chainid,privatekey=self.privatekey_list[2]) self.ppos_noconsensus_4 = Ppos(self.rpc_list[0], self.account_list[3],self.chainid,privatekey=self.privatekey_list[3]) self.ppos_noconsensus_5 = Ppos(self.rpc_list[0], self.account_list[4],self.chainid,privatekey=self.privatekey_list[4]) self.ppos_noconsensus_6 = Ppos(self.rpc_list[0], self.account_list[5],self.chainid,privatekey=self.privatekey_list[5]) self.eth = Eth(self.w3_list[0]) def transaction(self,w3, from_address, to_address=None,value=1000000000000000000000000000000000, gas=91000000, gasPrice=9000000000,pwd=conf.PASSWORD): """" 转账公共方法 """ personal = Personal(w3) personal.unlockAccount(from_address, pwd, 666666) params = { 'to': to_address, 'from': from_address, 'gas': gas, 'gasPrice': gasPrice, 'value': value } tx_hash = w3.eth.sendTransaction(params) result = w3.eth.waitForTransactionReceipt(HexBytes(tx_hash).hex()) return result def getCandidateList(self): """ 获取实时验证人的nodeID list """ msg = self.ppos_noconsensus_1.getCandidateList() recive_list = msg.get("Data") nodeid_list = [] if recive_list is None: return recive_list else: for node_info in recive_list: nodeid_list.append(node_info.get("NodeId")) return nodeid_list @allure.title("委托金额分别为{amount}") @pytest.mark.P1 @pytest.mark.parametrize('amount', [amount_delegate-1, 0]) def test_illege_delegate(self,amount): """ 用例id 委托金额小于门槛 """ log.info("转账每个钱包") for to_account in self.account_list: self.transaction(self.w3_list[0],self.address,to_address=to_account) log.info("质押节点1:{}成为验证人".format(self.nodeid_list2[0])) self.ppos_noconsensus_1.createStaking(0, self.account_list[0], self.nodeid_list2[0], self.externalId, self.nodeName, self.website, self.details, self.amount, self.programVersion) log.info("钱包2委托金额") msg = self.ppos_noconsensus_2.delegate(0, self.nodeid_list2[0], amount) log.info(msg) assert msg.get("Status") == False,"委托金额异常" @allure.title("质押过的钱包委托失败") @pytest.mark.P1 def test_delegate_verifier(self): """ 测试质押过的钱包不能去委托 """ log.info("转账到钱包1") self.transaction(self.w3_list[0], self.address, to_address=self.account_list[0]) log.info("转账到钱包2") self.transaction(self.w3_list[0], self.address, to_address=self.account_list[1]) amount = self.amount_delegate msg = self.ppos_noconsensus_1.getCandidateInfo(self.nodeid_list2[0]) if msg['Data']!= "": log.info("质押过的钱包1不能再去质押") msg = self.ppos_noconsensus_1.delegate(0, self.nodeid_list2[0], amount) # print(msg) assert msg.get("Status") == False msg_string = "is not allowed to be used for delegating" assert msg_string in msg["ErrMsg"], "质押过的钱包不能进行质押出现异常" else: log.info("质押节点1:{}成为验证人".format(self.nodeid_list2[0])) self.ppos_noconsensus_1.createStaking(0, self.account_list[0], self.nodeid_list2[0], self.externalId, self.nodeName, self.website, self.details, self.amount, self.programVersion) log.info("质押过的钱包1不能再去质押") msg = self.ppos_noconsensus_1.delegate(0, self.nodeid_list2[0], amount) assert msg.get("Status") == False log.info(msg) msg_string = "is not allowed to be used for delegating" assert msg_string in msg["ErrMsg"], "质押过的钱包不能进行质押出现异常" @allure.title("发起委托成功") @pytest.mark.P0 def test_delegate(self): """ 用例id 95 委托成功,查询节点信息,金额 用例id 98 委托人与验证人验证,验证人存在 """ log.info("转账到钱包1") self.transaction(self.w3_list[0], self.address, to_address=self.account_list[0]) log.info("转账到钱包2") self.transaction(self.w3_list[0], self.address, to_address=self.account_list[1]) amount = self.amount_delegate msg = self.ppos_noconsensus_1.getCandidateInfo(self.nodeid_list2[0]) if msg['Data']!= "": log.info("钱包2委托节点1") msg = self.ppos_noconsensus_2.delegate(0,self.nodeid_list2[0],amount) assert msg.get("Status") == True assert msg.get("ErrMsg") == 'ok' else: log.info("质押节点1:{}成为验证人".format(self.nodeid_list2[0])) self.ppos_noconsensus_1.createStaking(0, self.account_list[0], self.nodeid_list2[0], self.externalId, self.nodeName, self.website, self.details, self.amount, self.programVersion) msg = self.ppos_noconsensus_2.delegate(0,self.nodeid_list2[0],amount) assert msg.get("Status") == True assert msg.get("ErrMsg") == 'ok' @allure.title("查询当前单个委托信息") @pytest.mark.P0 def test_getDelegateInfo(self): """ 用例id 94 查询当前单个委托信息 """ log.info("转账到钱包5") self.transaction(self.w3_list[0], self.address, to_address=self.account_list[4]) log.info("转账到钱包6") self.transaction(self.w3_list[0], self.address, to_address=self.account_list[5]) log.info("质押节点5成为验证人") self.ppos_noconsensus_5.createStaking(0, self.account_list[4], self.nodeid_list2[4], self.externalId, self.nodeName, self.website, self.details, self.amount, self.programVersion) msg = self.ppos_noconsensus_6.delegate(0, self.nodeid_list2[4], self.amount_delegate) assert msg.get("Status") == True assert msg.get("ErrMsg") == 'ok' log.info("查询质押节点5信息") msg = self.ppos_noconsensus_5.getCandidateInfo(self.nodeid_list2[4]) assert msg["Data"]["NodeId"] == self.nodeid_list2[4] log.info("查询质押+委托的金额正确") assert Web3.fromWei(msg["Data"]["Shares"], 'ether') == self.amount + self.amount_delegate assert Web3.fromWei(msg["Data"]["ReleasedHes"], 'ether') == self.amount stakingBlockNum = msg["Data"]["StakingBlockNum"] log.info("质押的块高{}".format(stakingBlockNum)) msg = self.ppos_noconsensus_6.getDelegateInfo(stakingBlockNum, self.account_list[5], self.nodeid_list2[4]) data = msg["Data"] data = json.loads(data) assert Web3.toChecksumAddress(data["Addr"]) == self.account_list[5] assert data["NodeId"] == self.nodeid_list2[4] assert Web3.fromWei(data["ReleasedHes"], 'ether') == self.amount_delegate @allure.title("余额不足委托失败") @pytest.mark.P2 def test_insufficient_delegate(self): """ 用例96 余额不足委托失败 """ log.info("转账到钱包1") self.transaction(self.w3_list[0], self.address, to_address=self.account_list[0]) log.info("转账到钱包2") self.transaction(self.w3_list[0], self.address, to_address=self.account_list[1]) amount = 1000000000000000000000000000000 msg = self.ppos_noconsensus_1.getCandidateInfo(self.nodeid_list2[0]) if msg['Data']!= "": msg = self.ppos_noconsensus_2.delegate(0, self.nodeid_list2[0], amount) # print(msg) assert msg.get("Status") == False assert msg.get("ErrMsg") == 'Delegate failed: The von of account is not enough' else: log.info("质押节点1:{}成为验证人".format(self.nodeid_list2[0])) self.ppos_noconsensus_1.createStaking(0, self.account_list[0], self.nodeid_list2[0], self.externalId, self.nodeName, self.website, self.details, self.amount, self.programVersion) msg = self.ppos_noconsensus_2.delegate(0, self.nodeid_list2[0], amount) # print(msg) assert msg.get("Status") == False assert msg.get("ErrMsg") == 'Delegate failed: The von of account is not enough' @allure.title("验证人不存在进行委托") @pytest.mark.P2 def test_not_nodeId_delegate(self): """ 用例72 验证人不存在进行委托 """ log.info("转账到钱包2") self.transaction(self.w3_list[0], self.address, to_address=self.account_list[1]) value = self.amount_delegate nodeid = conf.illegal_nodeID msg = self.ppos_noconsensus_2.delegate(0, nodeid, value) print(msg) assert msg.get("Status") == False assert msg.get("ErrMsg") == 'This candidate is not exist' @allure.title("验证人退出后,委托人信息还存在") @pytest.mark.P1 def test_back_unStaking_commissioned(self): """ 用例id 82 验证人申请退回质押金,委托金额还生效 用例id 83 验证人退出后,委托人信息还存在 """ log.info("转账到钱包1") self.transaction(self.w3_list[0], self.address, to_address=self.account_list[0]) log.info("转账到钱包2") self.transaction(self.w3_list[0], self.address, to_address=self.account_list[1]) msg = self.ppos_noconsensus_1.getCandidateInfo(self.nodeid_list2[0]) if msg['Data']== "": log.info("节点1再次成为验证人") self.ppos_noconsensus_1.createStaking(0, self.account_list[0], self.nodeid_list2[0], self.externalId, self.nodeName, self.website, self.details, self.amount, self.programVersion) log.info("钱包2进行委托100") self.ppos_noconsensus_2.delegate(0, self.nodeid_list2[0], 100) log.info("节点1退出验证人") self.ppos_noconsensus_1.unStaking(self.nodeid_list2[0]) msg = self.ppos_noconsensus_2.getDelegateListByAddr(self.account_list[1]) log.info(msg) StakingBlockNum = msg["Data"][0]["StakingBlockNum"] msg = self.ppos_noconsensus_2.getDelegateInfo(StakingBlockNum,self.account_list[1],self.nodeid_list2[0]) log.info(msg) data = msg["Data"] data = json.loads(data) log.info(data) assert Web3.toChecksumAddress(data["Addr"]) == self.account_list[1] assert data["NodeId"] == self.nodeid_list2[0] else: log.info("钱包2进行委托100") self.ppos_noconsensus_2.delegate(0, self.nodeid_list2[0], 100) log.info("节点1退出验证人") self.ppos_noconsensus_1.unStaking(self.nodeid_list2[0]) msg = self.ppos_noconsensus_2.getDelegateListByAddr(self.account_list[1]) log.info(msg) StakingBlockNum = msg["Data"][0]["StakingBlockNum"] msg = self.ppos_noconsensus_2.getDelegateInfo(StakingBlockNum,self.account_list[1],self.nodeid_list2[0]) log.info(msg) data = msg["Data"] data = json.loads(data) log.info(data) assert Web3.toChecksumAddress(data["Addr"]) == self.account_list[1] assert data["NodeId"] == self.nodeid_list2[0] @allure.title("验证节点退出后,再成为验证节点,钱包委托信息有2个") @pytest.mark.P2 def test_identifier_quit_delegate(self): """ 委托验证节点,验证节点退出后,再成为验证节点,再去委托:预期有2个委托消息 """ log.info("转账到钱包3") self.transaction(self.w3_list[0], self.address, to_address=self.account_list[2]) log.info("转账到钱包4") self.transaction(self.w3_list[0], self.address, to_address=self.account_list[3]) log.info("质押节点3:{}成为验证节点".format(self.nodeid_list2[2])) self.ppos_noconsensus_3.createStaking(0, self.account_list[2], self.nodeid_list2[2], self.externalId, self.nodeName, self.website, self.details, self.amount, self.programVersion) log.info("钱包4:{}进行委托".format(self.account_list[3])) self.ppos_noconsensus_4.delegate(0,self.nodeid_list2[2],50) log.info("质押节点3退出验证人{}".format(self.nodeid_list2[2])) self.ppos_noconsensus_3.unStaking(self.nodeid_list2[2]) log.info("{}再次成为验证人".format(self.nodeid_list2[2])) self.ppos_noconsensus_3.createStaking(0, self.account_list[2],self.nodeid_list2[2],self.externalId, self.nodeName, self.website, self.details,self.amount,self.programVersion) log.info("钱包4:{}再次进行委托".format(self.account_list[3])) msg = self.ppos_noconsensus_4.delegate(0,self.nodeid_list2[2],100) print(msg) log.info("查询钱包的委托情况") msg = self.ppos_noconsensus_4.getDelegateListByAddr(self.account_list[3]) log.info(msg) log.info(msg["Data"]) print(len(msg["Data"])) assert len(msg["Data"]) == 2 for i in msg["Data"]: assert Web3.toChecksumAddress(i["Addr"]) == self.account_list[3] assert i["NodeId"] == self.nodeid_list2[2]
class TestAddstaking(): node_yml_path = conf.NODE_YML node_info = get_node_info(node_yml_path) rpc_list, enode_list, nodeid_list, ip_list, port_list = node_info.get( 'collusion') rpc_list2, enode_list2, nodeid_list2, ip_list2, port_list2 = node_info.get( 'nocollusion') address = Web3.toChecksumAddress(conf.ADDRESS) pwd = conf.PASSWORD privatekey = conf.PRIVATE_KEY account_list = conf.account_list privatekey_list = conf.privatekey_list externalId = "1111111111" nodeName = "platon" website = "https://www.test.network" details = "supper node" programVersion = 1792 illegal_nodeID = conf.illegal_nodeID genesis_path = conf.GENESIS_TMP """替换config.json""" get_config_data() config_json_path = conf.PLATON_CONFIG_PATH config_dict = LoadFile(config_json_path).get_data() amount_delegate = Web3.fromWei( int(config_dict['EconomicModel']['Staking']['MinimumThreshold']), 'ether') amount = Web3.fromWei( int(config_dict['EconomicModel']['Staking']['StakeThreshold']), 'ether') def setup_class(self): self.auto = AutoDeployPlaton() self.auto.start_all_node(self.node_yml_path) self.genesis_dict = LoadFile(self.genesis_path).get_data() self.chainid = int(self.genesis_dict["config"]["chainId"]) self.ppos_link = Ppos(self.rpc_list[0], self.address, self.chainid) self.ppos_link1 = Ppos(self.rpc_list[1], self.address, self.chainid) self.w3_list = [connect_web3(url) for url in self.rpc_list] """用新的钱包地址和未质押过的节点id封装对象""" self.ppos_noconsensus_1 = Ppos(self.rpc_list[0], self.account_list[0], self.chainid, privatekey=self.privatekey_list[0]) self.ppos_noconsensus_2 = Ppos(self.rpc_list[0], self.account_list[1], self.chainid, privatekey=self.privatekey_list[1]) self.ppos_noconsensus_3 = Ppos(self.rpc_list[0], self.account_list[2], self.chainid, privatekey=self.privatekey_list[2]) self.ppos_noconsensus_4 = Ppos(self.rpc_list[0], self.account_list[3], self.chainid, privatekey=self.privatekey_list[3]) self.ppos_noconsensus_5 = Ppos(self.rpc_list[0], self.account_list[4], self.chainid, privatekey=self.privatekey_list[4]) self.ppos_noconsensus_6 = Ppos(self.rpc_list[0], self.account_list[5], self.chainid, privatekey=self.privatekey_list[5]) self.eth = Eth(self.w3_list[0]) def transaction(self, w3, from_address, to_address=None, value=1000000000000000000000000000000000, gas=91000000, gasPrice=9000000000, pwd="88888888"): """" 转账公共方法 """ personal = Personal(w3) personal.unlockAccount(from_address, pwd, 666666) params = { 'to': to_address, 'from': from_address, 'gas': gas, 'gasPrice': gasPrice, 'value': value } tx_hash = w3.eth.sendTransaction(params) result = w3.eth.waitForTransactionReceipt(HexBytes(tx_hash).hex()) return result def getCandidateList(self): """ 获取实时验证人的nodeID list """ msg = self.ppos_noconsensus_1.getCandidateList() recive_list = msg.get("Data") nodeid_list = [] if recive_list is None: return recive_list else: for node_info in recive_list: nodeid_list.append(node_info.get("NodeId")) return nodeid_list @allure.title("增加质押分别为{amount}") @pytest.mark.P1 @pytest.mark.parametrize('amount', [100, 10000000, 1000000]) def test_add_staking(self, amount): """ 用例id 72 账户余额足够,增加质押成功 用例id 74 验证人在质押锁定期内增持的质押数量不限制 """ log.info("转账到钱包1") self.transaction(self.w3_list[0], self.address, to_address=self.account_list[0]) nodeId = self.nodeid_list2[0] log.info("钱包1做一笔质押") self.ppos_noconsensus_1.createStaking(0, self.account_list[0], nodeId, self.externalId, self.nodeName, self.website, self.details, self.amount, self.programVersion) log.info("分别验证增持{}".format(amount)) msg = self.ppos_noconsensus_1.addStaking(nodeId, typ=0, amount=amount) print(msg) assert msg.get("Status") == True, "返回状态错误" assert msg.get("ErrMsg") == 'ok', "返回消息错误" msg = self.ppos_noconsensus_1.getCandidateInfo(self.nodeid_list2[0]) nodeid = msg["Data"]["NodeId"] assert nodeid == self.nodeid_list2[0] if amount == 100: assert Web3.fromWei(msg["Data"]["Shares"], 'ether') == self.amount + 100 if amount == 10000000: assert Web3.fromWei(msg["Data"]["Shares"], 'ether') == self.amount + 100 + 10000000 if amount == 1000000: assert Web3.fromWei( msg["Data"]["Shares"], 'ether') == self.amount + 100 + 10000000 + 1000000 @allure.title("非验证人增持质押") @pytest.mark.P2 def test_not_illegal_addstaking(self): """ 用例id 78 非验证人增持质押 """ log.info("转账到钱包1") self.transaction(self.w3_list[0], self.address, to_address=self.account_list[0]) nodeId = conf.illegal_nodeID msg = self.ppos_noconsensus_1.getCandidateInfo(self.nodeid_list2[0]) if msg['Data'] == "": log.info("节点1成为验证人") self.ppos_noconsensus_1.createStaking(0, self.account_list[0], self.nodeid_list2[0], self.externalId, self.nodeName, self.website, self.details, self.amount, self.programVersion) msg = self.ppos_noconsensus_1.addStaking(nodeId=nodeId, typ=0, amount=100) assert msg.get("Status") == False, "返回状态错误" assert msg.get("ErrMsg") == 'This candidate is not exist', "非验证人增持质押异常" @allure.title("编辑验证人信息-未成为验证人的nodeID") @pytest.mark.P1 def test_editCandidate_nodeid(self): """ 验证修改未成为验证人的nodeID """ externalId = "88888888" nodeName = "wuyiqin" website = "www://baidu.com" details = "node_1" account = self.account_list[0] nodeid = conf.illegal_nodeID self.transaction(self.w3_list[0], self.address, to_address=self.account_list[1]) log.info("转账到钱包2") nodeId = self.nodeid_list2[1] msg = self.ppos_noconsensus_2.getCandidateInfo(nodeId) if msg['Data'] == "": log.info("节点2成为验证人") msg = self.ppos_noconsensus_2.createStaking( 0, self.account_list[1], nodeId, self.externalId, self.nodeName, self.website, self.details, self.amount, self.programVersion) assert msg.get("Status") == True, "返回状态错误" assert msg.get("ErrMsg") == 'ok', "返回消息错误" log.info("节点2修改节点信息") msg = self.ppos_noconsensus_2.updateStakingInfo( account, nodeid, externalId, nodeName, website, details) log.info(msg) assert msg.get("Status") == False, "返回状态错误" @allure.title("编辑验证人信息-参数有效性验证") @pytest.mark.P0 def test_editCandidate(self): """ 用例id 70 编辑验证人信息-参数有效性验证 """ externalId = "88888888" nodeName = "wuyiqin" website = "www://baidu.com" details = "node_1" account = self.account_list[0] self.transaction(self.w3_list[0], self.address, to_address=self.account_list[1]) log.info("转账到钱包2") nodeId = self.nodeid_list2[1] msg = self.ppos_noconsensus_2.getCandidateInfo(nodeId) if msg['Data'] == "": log.info("节点2成为验证人") msg = self.ppos_noconsensus_2.createStaking( 0, self.account_list[1], nodeId, self.externalId, self.nodeName, self.website, self.details, self.amount, self.programVersion) assert msg.get("Status") == True, "返回状态错误" assert msg.get("ErrMsg") == 'ok', "返回消息错误" log.info("节点2修改节点信息") msg = self.ppos_noconsensus_2.updateStakingInfo( account, self.nodeid_list2[1], externalId, nodeName, website, details) assert msg.get("Status") == True, "返回状态错误" assert msg.get("ErrMsg") == 'ok', "返回消息错误" log.info("查看节点2的信息") msg = self.ppos_noconsensus_2.getCandidateInfo(self.nodeid_list2[1]) log.info(msg) assert msg["Data"]["ExternalId"] == externalId assert msg["Data"]["NodeName"] == nodeName assert msg["Data"]["Website"] == website assert msg["Data"]["Details"] == details log.info(self.account_list[0]) BenefitAddress = Web3.toChecksumAddress(msg["Data"]["BenefitAddress"]) log.info(BenefitAddress) assert BenefitAddress == account @allure.title("修改钱包地址,更改后的地址收益正常") @pytest.mark.P2 def test_alter_address(self): """ 修改钱包地址,更改后的地址收益正常 """ log.info("转账到钱包2") self.transaction(self.w3_list[0], self.address, to_address=self.account_list[1]) externalId = "88888888" nodeName = "helloword" website = "www://dddddd.com" details = "node_2" ####没钱的钱包##### account = conf.no_money[0] balance_before = self.eth.getBalance(account) assert balance_before == 0 msg = self.ppos_noconsensus_1.getCandidateInfo(self.nodeid_list2[1]) if msg['Data'] == "": log.info("质押节点2成为验证节点") msg = self.ppos_noconsensus_2.createStaking( 0, self.account_list[0], self.nodeid_list2[1], self.externalId, self.nodeName, self.website, self.details, self.amount, self.programVersion) assert msg.get("Status") == True, "返回状态错误" assert msg.get("ErrMsg") == 'ok', "返回消息错误" log.info("修改节点2的信息") msg = self.ppos_noconsensus_2.updateStakingInfo( account, self.nodeid_list2[1], externalId, nodeName, website, details) assert msg.get("Status") == True, "返回状态错误" assert msg.get("ErrMsg") == 'ok', "返回消息错误" log.info("进入第2个结算周期") get_block_number(self.w3_list[0]) log.info("进入第3个结算周期") get_block_number(self.w3_list[0]) balance_after = self.eth.getBalance(account) log.info(balance_after) assert balance_after > 0, "修改后的钱包余额没增加" assert balance_after > balance_before, "地址更改后未发现余额增加" @allure.title("增加质押为{x}") @pytest.mark.P2 @pytest.mark.parametrize('x', [0, (amount_delegate - 1)]) def test_add_staking_zero(self, x): """测试增持金额为0,低于门槛""" log.info("转账到钱包3") self.transaction(self.w3_list[0], self.address, to_address=self.account_list[2]) log.info("质押节点3,成为验证人") nodeId = self.nodeid_list2[2] self.ppos_noconsensus_3.createStaking(0, self.account_list[2], nodeId, self.externalId, self.nodeName, self.website, self.details, self.amount, self.programVersion) log.info("节点3增持质押".format(x)) msg = self.ppos_noconsensus_3.addStaking(nodeId, typ=0, amount=x) log.info(msg) assert msg.get("Status") == False, "返回状态错误" @allure.title("账户余额不足增加质押") @pytest.mark.P2 def test_Insufficient_addStaking(self): """ 用例id 73 账户余额不足,增加质押失败 """ log.info("转账到钱包5") self.transaction(self.w3_list[0], self.address, to_address=self.account_list[4]) log.info("质押节点5成为验证人") nodeId = self.nodeid_list2[4] msg = self.ppos_noconsensus_5.createStaking( 0, self.account_list[4], nodeId, self.externalId, self.nodeName, self.website, self.details, self.amount, self.programVersion) assert msg.get("Status") == True, "返回状态错误" amount = 100000000000000000000000000000000000 msg = self.ppos_noconsensus_5.addStaking(nodeId=nodeId, typ=0, amount=amount) assert msg.get("Status") == False, "返回状态错误" msg_string = "The von of account is not enough" assert msg_string in msg.get("ErrMsg"), "余额不足发生质押异常" # @allure.title("验证人已申请退出中,申请增持质押") # def test_quit_and_addstaking(self): # """ # 用例id 77 验证人已申请退出中,申请增持质押 # """ # nodeId = self.nodeid_list2[0] # msg = self.ppos_noconsensus_1.unStaking(nodeId) # assert msg.get("Status") == True, "返回状态错误" # assert msg.get("ErrMsg") == 'ok', "返回消错误" # log.info("{}已经退出验证人.".format(nodeId)) # node_list = self.getCandidateList() # log.info(self.nodeid_list2[0]) # log.info(node_list) # assert self.nodeid_list2[0] not in node_list # """验证人退出后,查询实时验证人列表返回的是空,可能是bug""" # msg = self.ppos_noconsensus_1.addStaking(nodeId, typ=0, amount=100) # assert msg.get("Status") == True, "返回状态错误" # assert msg.get("ErrMsg") == 'This candidate is not exist' @allure.title("验证人已申请退出中,申请增持质押") @pytest.mark.P1 def test_quit_and_addstaking(self): """ 用例id 77 验证人已申请退出中,申请增持质押 """ log.info("转账到钱包4") self.transaction(self.w3_list[0], self.address, to_address=self.account_list[3]) nodeId = self.nodeid_list2[3] log.info("节点4发起质押") msg = self.ppos_noconsensus_4.createStaking( 0, self.account_list[3], nodeId, self.externalId, self.nodeName, self.website, self.details, self.amount, self.programVersion) assert msg.get("Status") == True, "质押失败" log.info("节点4退出质押") msg = self.ppos_noconsensus_4.unStaking(nodeId) # print(msg) assert msg.get("Status") == True, "返回状态错误" assert msg.get("ErrMsg") == 'ok', "返回消息错误" log.info("{}已经退出验证人.".format(nodeId)) node_list = self.getCandidateList() # print(nodeId) # print(node_list) assert nodeId not in node_list msg = self.ppos_noconsensus_1.getCandidateInfo(nodeId) assert msg['Data'] == "" msg = self.ppos_noconsensus_4.addStaking(nodeId, typ=0, amount=100) assert msg.get("Status") == False, "返回状态错误" assert msg.get("ErrMsg") == 'This candidate is not exist'
class TestPledge(): node_yml_path = conf.PPOS_NODE_YML node_info = get_node_info(node_yml_path) rpc_list, enode_list, nodeid_list, ip_list, port_list = node_info.get( 'collusion') rpc_list2, enode_list2, nodeid_list2, ip_list2, port_list2 = node_info.get( 'nocollusion') address = Web3.toChecksumAddress(conf.ADDRESS) pwd = conf.PASSWORD privatekey = conf.PRIVATE_KEY account_list = conf.account_list privatekey_list = conf.privatekey_list externalId = "1111111111" nodeName = "platon" website = "https://www.test.network" details = "supper node" amount = 1000000 programVersion = 1792 illegal_nodeID = conf.illegal_nodeID def setup_class(self): self.ppos_link = Ppos( self.rpc_list[0], self.address) self.w3_list = [connect_web3(url) for url in self.rpc_list] """用新的钱包地址和未质押过的节点id封装对象""" self.ppos_noconsensus_1 = Ppos(self.rpc_list[0], self.account_list[0], privatekey= self.privatekey_list[0]) self.ppos_noconsensus_2 = Ppos(self.rpc_list[0], self.account_list[1], privatekey=self.privatekey_list[1]) self.ppos_noconsensus_3 = Ppos(self.rpc_list[0], self.account_list[2], privatekey=self.privatekey_list[2]) for to_account in self.account_list: self.transaction(self.w3_list[0],self.address,to_account) def transaction(self,w3, from_address, to_address=None, value=100000000000000000000000000000000, gas=91000000, gasPrice=9000000000): personal = Personal(self.w3_list[0]) personal.unlockAccount(self.address, self.pwd, 666666) params = { 'to': to_address, 'from': from_address, 'gas': gas, 'gasPrice': gasPrice, 'value': value } tx_hash = w3.eth.sendTransaction(params) return tx_hash def test_initial_identifier(self): """ 用例id 54,55 测试验证人参数有效性验证 """ recive = self.ppos_link.getVerifierList() recive_list = recive.get("Data") nodeid_list=[] # 查看查询当前结算周期的验证人队列 for node_info in recive_list: nodeid_list.append(node_info.get("NodeId")) StakingAddress = node_info.get("StakingAddress") assert StakingAddress == self.address,"内置钱包地址错误{}".format(StakingAddress) # print(recive) # print(nodeid_list) assert nodeid_list == nodeid_list, "正常的nodeID列表{},异常的nodeID列表{}".format(nodeid_list,recive_list) def test_initial_cannot_entrust(self): """ 用例id 56 初始验证人不能接受委托 """ msg = self.ppos_link.delegate(typ = 1,nodeId=self.nodeid_list[0],amount=50) assert msg.get("Status") == False ,"返回状态错误" assert msg.get("ErrMsg") == 'This candidate is not allow to delegate',"返回提示语错误" def test_initial_add_pledge(self): """ 用例id 57 初始验证人增持质押 """ msg = self.ppos_link.addStaking(nodeId=self.nodeid_list[0],typ=0,amount=1000) print(msg) assert msg.get("Status") == True assert msg.get("ErrMsg") == 'ok' def test_initial_quit(self): """ 用例id 58 初始验证人退出 """ msg = self.ppos_link.unStaking(nodeId=self.nodeid_list[0]) print(self.nodeid_list[0]) assert msg.get("Status") ==True assert msg.get("ErrMsg") == 'ok' """暂时没配置参数所以还要调整""" time.sleep(10) recive = self.ppos_link.getCandidateList() recive_list = recive.get("Data") for node_info in recive_list: # print(node_info) assert node_info.get("NodeId") != self.nodeid_list[0] def test_staking(self): """ 用例 62 非初始验证人做质押 """ nodeId = self.nodeid_list2[0] """非共识节点做一笔质押""" msg = self.ppos_noconsensus_1.createStaking(0, self.account_list[1], nodeId,self.externalId,self.nodeName, self.website,self.details, self.amount,self.programVersion) print(msg) assert msg.get("Status") ==True assert msg.get("ErrMsg") == 'ok' """暂时没配置参数所以还要调整""" ##查看实时验证人信息 recive = self.ppos_noconsensus_1.getCandidateList() recive_list = recive.get("Data") nodeid_list = [] for node_info in recive_list: nodeid_list.append(node_info.get("NodeId")) assert self.nodeid_list2[0] in nodeid_list,"非初始验证人质押失败" def test_staking_zero(self): """ 用例 64 非初始验证人做质押,质押金额小于最低门槛 """ benifitAddress = self.account_list[1] nodeId = self.nodeid_list2[0] """非共识节点做一笔质押""" amount = 100000 msg = self.ppos_noconsensus_1.createStaking(0, benifitAddress, nodeId,self.externalId,self.nodeName, self.website, self.details,amount,self.programVersion) print(msg) assert msg.get("Status") ==False def test_not_illegal_addstaking(self): """ 用例id 78 非初始验证人成为验证人后,增持质押 """ nodeId = conf.illegal_nodeID msg = self.ppos_noconsensus_1.addStaking(nodeId=nodeId, typ=0, amount=100) assert msg.get("Status") == False assert msg.get("ErrMsg") == 'This candidate is not exist' def test_illegal_pledge(self): """ 用例id 63 非链上的nodeID去质押 """ benifitAddress = self.account_list[1] msg = self.ppos_noconsensus_2.createStaking(0, benifitAddress,self.illegal_nodeID,self.externalId, self.nodeName, self.website, self.details,self.amount,self.programVersion) print(msg) assert msg.get("Status") ==True assert msg.get("ErrMsg") == 'ok' def test_getCandidateInfo(self): """ 用例69 查询验证人信息,调用质押节点信息 """ msg = self.ppos_noconsensus_1.getCandidateInfo(self.nodeid_list2[0]) nodeid = msg["Data"]["NodeId"] """验证质押金额""" assert msg["Data"]["Shares"] == 1000000000000000000000000 assert nodeid == self.nodeid_list[0] msg = self.ppos_link.getCandidateInfo(self.nodeid_list[0]) # print(msg) nodeid = msg["Data"]["NodeId"] assert nodeid == self.nodeid_list[0] # @pytest.mark.parametrize("externalId,nodeName,website,details",[("88888888","jay_wu","https://baidu.com,node_1"), # ("","","","")]) # def test_editCandidate(self,externalId,nodeName,website,details): # """ # 用例id 70 编辑验证人信息-参数有效性验证 # """ # msg = self.ppos_noconsensus_1.updateStakingInfo(self.account_list[0], self.nodeid_list2[0], # externalId, nodeName, website, details) # print(msg) # msg = self.ppos_noconsensus_1.getCandidateInfo(self.nodeid_list2[0]) # print(msg) def test_editCandidate(self): """ 用例id 70 编辑验证人信息-参数有效性验证 """ externalId = "88888888" nodeName = "jay_wu" website = "www://baidu.com" details = "node_1" msg = self.ppos_noconsensus_1.updateStakingInfo(self.account_list[0], self.nodeid_list2[0], externalId, nodeName, website, details) assert msg.get("Status") ==True assert msg.get("ErrMsg") == 'ok' msg = self.ppos_noconsensus_1.getCandidateInfo(self.nodeid_list2[0]) print(msg) assert msg["Data"]["ExternalId"] == externalId assert msg["Data"]["nodeName"] == nodeName assert msg["Data"]["website"] == website assert msg["Data"]["details"] == details @pytest.mark.parametrize('amount', [(100),(10000000),(1000000)]) def test_add_staking(self,amount): """ 用例id 72 账户余额足够,增加质押成功 用例id 74 验证人在质押锁定期内增持的质押数量不限制 """ nodeId = self.nodeid_list2[0] msg = self.ppos_noconsensus_1.addStaking(nodeId,typ=0,amount=amount) assert msg.get("Status") == True assert msg.get("ErrMsg") == 'ok' def test_add_staking_zero(self): """测试增持金额为0""" nodeId = self.nodeid_list2[0] msg = self.ppos_noconsensus_1.addStaking(nodeId,typ=0,amount=0) assert msg.get("Status") == False def test_Insufficient_delegate(self): """ 用例id 73 账户余额不足,增加质押失败 """ amount = 100000000000000000000000000000000000 nodeId = self.nodeid_list2[0] msg = self.ppos_noconsensus_1.addStaking(nodeId=nodeId,typ=0,amount=amount) # print(msg) assert msg.get("Status") == False assert msg.get("ErrMsg") == 'The von of account is not enough' def test_quit_and_addstaking(self): """ 用例id 77 验证人已申请退出中,申请增持质押 """ nodeId = self.nodeid_list2[0] msg = self.ppos_noconsensus_1.unStaking(nodeId) assert msg.get("Status") == True assert msg.get("ErrMsg") == 'ok' time.sleep(2) msg = self.ppos_noconsensus_1.addStaking(nodeId,typ=0,amount=100) assert msg.get("Status") == True assert msg.get("ErrMsg") == 'This candidate is not exist' # def test_getDelegateInfo(self): # """ # 用例id 94 查询委托参数验证 # """ # stakingBlockNum = "" # msg = self.ppos_noconsensus_1.getDelegateInfo(stakingBlockNum,delAddr,nodeId) def test_illege_delegate(self): """ 用例id 首次委托金额必须大于10 eth """ amount = 9 msg = self.ppos_noconsensus_2.delegate(0,self.nodeid_list2[0],amount) print(msg) assert msg.get("Status") == False assert msg.get("ErrMsg") == "Delegate deposit too low" amount = 0 msg = self.ppos_noconsensus_2.delegate(0, self.nodeid_list2[0], amount) assert msg.get("Status") == False assert msg.get("ErrMsg") == "This amount is illege" def test_delegate(self): """ 用例95 委托成功,查询节点信息,金额 用例id 98 委托人与验证人验证,验证人存在 """ amount = 1000 msg = self.ppos_noconsensus_2.delegate(0,self.illegal_nodeID,amount) assert msg.get("Status") == True assert msg.get("ErrMsg") == 'ok' def test_getDelegateInfo(self): """ 用例id 94 查询委托参数验证 """ msg = self.ppos_noconsensus_2.getCandidateInfo(self.illegal_nodeID) print(msg) assert msg["Data"]["NodeId"] == self.illegal_nodeID """查询当前候选人总共质押加被委托的von数目""" assert msg["Data"]["Shares"] == 1001000000000000000000000 assert msg["Data"]["ReleasedHes"] == 1000000000000000000000000 """通过查询""" stakingBlockNum = msg["Data"]["StakingBlockNum"] # print(stakingBlockNum) msg = self.ppos_noconsensus_2.getDelegateInfo(stakingBlockNum,self.account_list[1],self.illegal_nodeID) print(msg) assert msg["Data"]["Addr"] == self.account_list[1] assert msg["Data"]["NodeId"] == self.illegal_nodeID assert msg["Data"]["ReleasedHes"] == 1000000000000000000000 def test_insufficient_delegate(self): """ 用例96 余额不足委托失败 """ amount = 100000000000000000000000000 msg = self.ppos_noconsensus_2.delegate(0,self.illegal_nodeID,amount) # print(msg) assert msg.get("Status") == False assert msg.get("ErrMsg") == 'Delegate failed: The von of account is not enough' def test_not_nodeId_delegate(self): """ 用例72 验证人不存在进行委托 """ amount = 1000 msg = self.ppos_noconsensus_2.delegate(0,self.nodeid_list2[2],amount) print(msg) assert msg.get("Status") == False assert msg.get("ErrMsg") == 'This candidate is not exist' def test_restrictingPlan_delegate(self): """ 用例id 101 委托人使用锁仓Token进行委托 """ pass def test_restrictingPlan_insufficient_delegate(self): """ 用例id 103委托人使用锁仓Token(余额不足)进行委托 """ def
class TestBuildBlockChain: node_yml = conf.NODE_YML collusion_list, nocollusion_list = get_node_list(node_yml) one_collusion_url = nocollusion_list[0]["url"] data = get_node_info(node_yml) rpc_urls, enode_list, nodeid_list, _, _ = data["collusion"] w3_list = [connect_web3(url) for url in rpc_urls] genesis_file = conf.GENESIS_TMP auto = AutoDeployPlaton() def setup(self): self.auto.start_all_node(self.node_yml) def setup_class(self): self.w3_list = [connect_web3(url) for url in self.rpc_urls] def teardown_class(self): self.auto.start_all_node(self.node_yml) @allure.title("区块增长") def test_blocknumber_increase(self): ''' 测试块高是否正常增长 ''' for w3 in self.w3_list: for i in range(91): if w3.eth.blockNumber > 0: break time.sleep(1) if i == 90: raise Exception('区块不增长,块高:{}'.format(w3.eth.blockNumber)) # TODO: need fix python-sdk nonce bug # @allure.title("区块信息是否一致") # def test_block_synchronize(self): # ''' # 测试所有节点区块信息是否一致 # ''' # w3 = self.w3_list[0] # blocknumber = w3.eth.blockNumber # if blocknumber == 0: # time.sleep(15) # blocknumber = w3.eth.blockNumber # blockinfo = w3.eth.getBlock(blocknumber)['hash'] # for w in self.w3_list[1:-1]: # info = w.eth.getBlock(blocknumber)['hash'] # assert blockinfo == info, "不同节点的相同块高信息不一致区块号:{}".format( # blocknumber) # TODO: need fix python-sdk nonce bug # @allure.title("区块连续性,验证hash") # def test_hash_continuous(self): # """ # 测试区块的连续性,验证一定数量的区块,区块哈希必须是连续的 # """ # w3 = self.w3_list[0] # i = 0 # while True: # if w3.eth.blockNumber >= 100: # break # time.sleep(10) # i += 10 # if i >= 150: # assert False, "出块不正常" # block_hash = HexBytes(w3.eth.getBlock(1).get("hash")).hex() # for i in range(2, 100): # block = w3.eth.getBlock(i) # parent_hash = HexBytes(block.get("parentHash")).hex() # assert block_hash == parent_hash, "父区块哈希值错误" # block_hash = HexBytes(block.get("hash")).hex() @allure.title("不初始化启动节点和不同创世文件的节点互连") def test_no_init_no_join_chain(self): ''' 不初始化启动节点 ''' self.auto.start_of_list(self.nocollusion_list[0:1], is_need_init=False, clean=True) time.sleep(1) w3 = connect_web3(self.one_collusion_url) start_block = w3.eth.blockNumber time.sleep(10) end_block = w3.eth.blockNumber assert start_block == end_block, "区块高度增长了,开始块高{}-结束块高{}".format( start_block, end_block) w3.admin.addPeer(self.enode_list[0]) time.sleep(5) net_num = w3.net.peerCount assert net_num == 0, "连接节点数有增加" @allure.title("测试部署单节点私链") def test_build_one_node_privatechain(self): ''' 部署单节点私链 ''' auto = AutoDeployPlaton(genesis=conf.GENESIS_TEMPLATE2) auto.start_of_list(self.nocollusion_list[0:1], genesis_path=conf.GENESIS_TMP_OTHER) time.sleep(2) w3 = connect_web3(self.one_collusion_url) start_block = w3.eth.blockNumber log.info("start block number:{}".format(start_block)) time.sleep(10) end_block = w3.eth.blockNumber log.info("end block number:{}".format(end_block)) assert start_block < end_block, "区块高度没有增长" @allure.title("测试不同initnode创始文件之间节点互连") def test_init_diff_genesis_join_chain(self): ''' 使用不同genesis.json,addPeer ''' self.auto.start_of_list(self.nocollusion_list[0:1], genesis_path=conf.GENESIS_TMP_OTHER) time.sleep(2) net_num_1 = self.w3_list[0].net.peerCount w3 = connect_web3(self.one_collusion_url) w3.admin.addPeer(self.enode_list[0]) time.sleep(5) net_num_2 = self.w3_list[0].net.peerCount assert net_num_2 == net_num_1, "节点数有增加" peers = w3.net.peerCount log.info("加入其他链后,连接节点数{}".format(peers)) assert peers is 0, "peers节点数不为空" @allure.title("测试相同创始文件之间节点互连") def test_init_same_genesis_join_chain(self): ''' 测试相同的genesis.json节点加入addPeer ''' self.auto.start_of_list(self.nocollusion_list[0:1], genesis_file=self.genesis_file) time.sleep(2) w3 = connect_web3(self.one_collusion_url) w3.admin.addPeer(self.enode_list[0]) time.sleep(5) assert w3.net.peerCount > 0, "加入链失败" @allure.title("测试区块同步") def test_deconsensus_block_synchronize(self): ''' 非共识节点块高同步 ''' w3 = connect_web3(self.one_collusion_url) log.info(w3.net.peerCount) time.sleep(10) block_number = w3.eth.blockNumber assert block_number > 0, "非共识节点同步区块失败,块高:{}".format(block_number) @allure.title("测试fast模式同步") def test_syncmode(self): """ 同步 :return: """ auto = AutoDeployPlaton(syncmode="fast") auto.start_of_list(self.nocollusion_list[0:1], genesis_file=self.genesis_file) time.sleep(2) w3 = connect_web3(self.one_collusion_url) w3.admin.addPeer(self.enode_list[0]) time.sleep(5) collusion_w3 = self.w3_list[0] if collusion_w3.eth.blockNumber < 250: log.info("sleep,非共识节点需要229个块之后才会开始同步") time.sleep(250 - collusion_w3.eth.blockNumber) assert w3.net.peerCount > 0, "加入链失败" assert w3.eth.blockNumber >= 200, "区块同步失败,当前块高{}".format( w3.eth.blockNumber) # 目前没有测试网配置 # @allure.title("测试种子节点") # def test_testnet(self): # """ # 测试testnet连接 # :return: # """ # if conf.IS_TEST_NET: # auto = AutoDeployPlaton(net_type="testnet") # auto.start_all_node(conf.TEST_NET_NODE, # is_need_init=False, clean=True) # collusion, nocollusion = get_node_list(conf.TEST_NET_NODE) # time.sleep(10) # block_list = [] # net_list = [] # for nodedict in collusion: # url = nodedict["url"] # w3 = connect_web3(url) # block_list.append(w3.eth.blockNumber) # net_list.append(w3.net.peerCount) # log.info(block_list, net_list) # assert min(block_list) > 0, "区块没有增长" # for net in net_list: # assert net >= len(collusion) - \ # 1, "共识节点连接节点数少于{}个".format(len(collusion) - 1) # nocollusion_block_list = [] # nocollusion_net_list = [] # if max(block_list) < 250: # time.sleep(250 - max(block_list) + 10) # for nodedict in nocollusion: # url = nodedict["url"] # w3 = connect_web3(url) # nocollusion_block_list.append(w3.eth.blockNumber) # nocollusion_net_list.append(w3.net.peerCount) # log.info(nocollusion_block_list, nocollusion_net_list) # assert min(nocollusion_block_list) > 0, "区块没有增长" # for net in nocollusion_net_list: # assert net >= 1, "非共识节点没有连上测试网" # else: # pass @allure.title("测试platon文件的版本号") def test_platon_versions(self): collusion_list, _ = get_node_list(self.node_yml) node = collusion_list[0] ssh, sftp, t = connect_linux(node['host'], username=node['username'], password=node['password']) cmd_list = run_ssh( ssh, "{}/node-{}/platon version".format(conf.DEPLOY_PATH, node["port"])) versions = conf.VERSION assert versions in cmd_list[1], "版本号不正确" @allure.title("测试重启所有共识节点") def test_restart_all(self): current_block = self.w3_list[0].eth.blockNumber log.info("重启前块高:{}".format(current_block)) self.auto.restart_list(self.collusion_list) log.info("重启所有共识节点成功") time.sleep(30) after_block = self.w3_list[0].eth.blockNumber log.info("重启后块高为:{}".format(after_block)) assert after_block - current_block >= 10, "重启后区块没有正常增长"
class TestLockup(): node_yml_path = conf.NODE_YML node_info = get_node_info(node_yml_path) rpc_list, enode_list, nodeid_list, ip_list, port_list = node_info.get( 'collusion') rpc_list2, enode_list2, nodeid_list2, ip_list2, port_list2 = node_info.get( 'nocollusion') address = Web3.toChecksumAddress(conf.ADDRESS) privatekey = conf.PRIVATE_KEY account_list = conf.account_list privatekey_list = conf.privatekey_list externalId = "1111111111" nodeName = "platon" website = "https://www.test.network" details = "supper node" programVersion = 1792 illegal_nodeID = conf.illegal_nodeID genesis_path = conf.GENESIS_TMP get_config_data() config_json_path = conf.PLATON_CONFIG_PATH config_dict = LoadFile(config_json_path).get_data() amount_delegate = Web3.fromWei( int(config_dict['EconomicModel']['Staking']['MinimumThreshold']), 'ether') amount = Web3.fromWei( int(config_dict['EconomicModel']['Staking']['StakeThreshold']), 'ether') def setup_class(self): self.auto = AutoDeployPlaton() self.auto.start_all_node(self.node_yml_path) self.genesis_dict = LoadFile(self.genesis_path).get_data() self.chainid = int(self.genesis_dict["config"]["chainId"]) self.ppos_link = Ppos(self.rpc_list[0], self.address, self.chainid) self.w3_list = [connect_web3(url) for url in self.rpc_list] """用新的钱包地址和未质押过的节点id封装对象""" self.ppos_noconsensus_1 = Ppos(self.rpc_list[0], self.account_list[0], self.chainid, privatekey=self.privatekey_list[0]) self.ppos_noconsensus_2 = Ppos(self.rpc_list[0], self.account_list[1], self.chainid, privatekey=self.privatekey_list[1]) self.ppos_noconsensus_3 = Ppos(self.rpc_list[0], self.account_list[2], self.chainid, privatekey=self.privatekey_list[2]) self.ppos_noconsensus_4 = Ppos(self.rpc_list[0], self.account_list[3], self.chainid, privatekey=self.privatekey_list[3]) self.ppos_noconsensus_5 = Ppos(self.rpc_list[0], self.account_list[4], self.chainid, privatekey=self.privatekey_list[4]) self.ppos_noconsensus_6 = Ppos(self.rpc_list[0], self.account_list[5], self.chainid, privatekey=self.privatekey_list[5]) self.eth = Eth(self.w3_list[0]) def transaction(self, w3, from_address, to_address=None, value=100000000000000000000000000000000, gas=91000000, gasPrice=9000000000, pwd=conf.PASSWORD): """" 转账公共方法,转账1000w eth """ personal = Personal(w3) personal.unlockAccount(from_address, pwd, 666666) params = { 'to': to_address, 'from': from_address, 'gas': gas, 'gasPrice': gasPrice, 'value': value } tx_hash = w3.eth.sendTransaction(params) result = w3.eth.waitForTransactionReceipt(HexBytes(tx_hash).hex()) return result def getCandidateList(self): """ 获取实时验证人的nodeID list """ msg = self.ppos_noconsensus_1.getCandidateList() recive_list = msg.get("Data") nodeid_list = [] if recive_list is None: return recive_list else: for node_info in recive_list: nodeid_list.append(node_info.get("NodeId")) return nodeid_list @allure.title("验证人退回质押金(未到达可解锁期)") @pytest.mark.P0 def test_back_unstaking(self): """ 验证人退回质押金(未到达可解锁期) 质押成为下个周期验证人,退出后,下一个结算周期退出 """ log.info("转账每个钱包") for to_account in self.account_list: self.transaction(self.w3_list[0], self.address, to_address=to_account) log.info("节点1质押金额{} eth".format(self.amount)) self.ppos_noconsensus_1.createStaking(0, self.account_list[0], self.nodeid_list2[0], self.externalId, self.nodeName, self.website, self.details, self.amount, self.programVersion) account_1 = self.eth.getBalance(self.account_list[0]) log.info(account_1) get_block_number(self.w3_list[0]) log.info("查询第2个结算周期的验证人") node_list = getVerifierList() log.info(node_list) assert self.nodeid_list2[0] in node_list log.info("节点1在第2结算周期,锁定期申请退回") self.ppos_noconsensus_1.unStaking(nodeId=self.nodeid_list2[0]) """发起退回消耗一定gas""" account_2 = self.eth.getBalance(self.account_list[0]) log.info(account_2) assert account_1 > account_2, "发起退回的交易钱包异常" log.info("进入第3个结算周期") get_block_number(w3=self.w3_list[0]) account_3 = self.eth.getBalance(self.account_list[0]) log.info(account_3) assert account_3 > account_2 assert account_3 - account_2 < Web3.toWei(self.amount, "ether") log.info(account_3 - account_2) node_list = getVerifierList() log.info(node_list) assert self.nodeid_list2[0] not in node_list log.info("进入第4个结算周期") get_block_number(w3=self.w3_list[0]) account_4 = self.eth.getBalance(self.account_list[0]) log.info(account_4) """ 第3个结算周期结束后质押金额已退 """ log.info(account_4 - account_3) assert account_4 - account_3 > Web3.toWei(self.amount, "ether") assert account_4 - account_2 > Web3.toWei(self.amount, "ether") @allure.title("锁定期增加质押与委托") @pytest.mark.P0 def test_lockup_addstaking(self): """ 用例id74 锁定期增加质押 用例id 112 锁定期委托人进行委托 """ log.info("转账每个钱包") for to_account in self.account_list: self.transaction(self.w3_list[0], self.address, to_address=to_account) msg = self.ppos_noconsensus_1.getCandidateInfo(self.nodeid_list2[0]) if msg["Data"] == "": log.info("节点1质押金额{} eth".format(self.amount)) self.ppos_noconsensus_1.createStaking(0, self.account_list[0], self.nodeid_list2[0], self.externalId, self.nodeName, self.website, self.details, self.amount, self.programVersion) log.info("进入锁定期") get_block_number(self.w3_list[0]) value = 100 msg = self.ppos_noconsensus_1.addStaking(self.nodeid_list2[0], 0, value) assert msg.get("Status") == True msg = self.ppos_noconsensus_1.getCandidateInfo(self.nodeid_list2[0]) log.info(msg) nodeid = msg["Data"]["NodeId"] log.info("增持后验证质押金额") assert msg["Data"]["Shares"] == 1000100000000000000000000 assert msg["Data"]["Released"] == 1000000000000000000000000 assert msg["Data"]["ReleasedHes"] == 100000000000000000000 assert nodeid == self.nodeid_list2[0] self.ppos_noconsensus_2.delegate(0, self.nodeid_list2[0], 10) msg = self.ppos_noconsensus_2.getCandidateInfo(self.nodeid_list2[0]) log.info(msg) assert msg["Data"]["Shares"] == 1000110000000000000000000 stakingBlockNum = msg["Data"]["StakingBlockNum"] msg = self.ppos_noconsensus_2.getDelegateInfo(stakingBlockNum, self.account_list[1], self.nodeid_list2[0]) data = msg["Data"] data = json.loads(data) assert Web3.toChecksumAddress(data["Addr"]) == self.account_list[1] assert data["NodeId"] == self.nodeid_list2[0] # assert Web3.fromWei(data["ReleasedHes"], 'ether') == 10 @allure.title("验证根据质押+委托金额金额排名") @pytest.mark.P2 def test_taking_cycle_ranking(self): """ 验证根据质押金额排名 """ log.info("转账每个钱包") for to_account in self.account_list: self.transaction(self.w3_list[0], self.address, to_address=to_account) log.info("质押节点2") self.ppos_noconsensus_2.createStaking(0, self.account_list[1], self.nodeid_list2[1], self.externalId, self.nodeName, self.website, self.details, self.amount, self.programVersion) log.info("质押节点3") self.ppos_noconsensus_3.createStaking(0, self.account_list[2], self.nodeid_list2[2], self.externalId, self.nodeName, self.website, self.details, self.amount + 130, self.programVersion) log.info("进入到下个结算周期") get_block_number(w3=self.w3_list[0]) node_list = getVerifierList() log.info(node_list) msg = self.ppos_noconsensus_1.getCandidateInfo(self.nodeid_list2[1]) log.info(msg) msg = self.ppos_noconsensus_1.getCandidateInfo(self.nodeid_list2[2]) log.info(msg) assert self.nodeid_list2[2] in node_list assert self.nodeid_list2[1] in node_list assert self.nodeid_list2[2] == node_list[0] log.info("钱包4委托节点2 70eth") msg = self.ppos_noconsensus_4.delegate(0, nodeId=self.nodeid_list2[1], amount=70) print(msg) log.info("节点2增加质押61 eth") msg = self.ppos_noconsensus_2.addStaking(self.nodeid_list2[1], 0, amount=61) print(msg) log.info("进入下一个结算周期") get_block_number(self.w3_list[0]) node_list = getVerifierList() log.info(node_list) log.info(self.nodeid_list2[1]) log.info(self.nodeid_list2[2]) """预期节点2排在节点3之前""" msg = self.ppos_noconsensus_2.getCandidateInfo(self.nodeid_list2[1]) log.info(msg) msg = self.ppos_noconsensus_3.getCandidateInfo(self.nodeid_list2[2]) log.info(msg) assert node_list[0] == self.nodeid_list2[1] assert node_list[1] == self.nodeid_list2[2] @allure.title("质押相等的金额,按照时间先早排序") @pytest.mark.P1 def test_same_amount_cycle(self): """ 质押相等的金额,按照时间先早排序 """ self.auto = AutoDeployPlaton() self.auto.start_all_node(self.node_yml_path) log.info("转账每个钱包") for to_account in self.account_list: self.transaction(self.w3_list[0], self.address, to_address=to_account) log.info("质押节点4金额200eth") self.ppos_noconsensus_4.createStaking(0, self.account_list[3], self.nodeid_list2[3], self.externalId, self.nodeName, self.website, self.details, self.amount + 200, self.programVersion) log.info("质押节点5金额200eth") self.ppos_noconsensus_5.createStaking(0, self.account_list[4], self.nodeid_list2[4], self.externalId, self.nodeName, self.website, self.details, self.amount + 200, self.programVersion) log.info("进入到下个结算周期") get_block_number(self.w3_list[0]) node_list = getVerifierList() log.info(node_list) log.info(self.nodeid_list2[3]) log.info(self.nodeid_list2[4]) assert node_list[0] == self.nodeid_list2[3] assert node_list[1] == self.nodeid_list2[4] @allure.title("验证人申请退回所有质押金(包含初始质押金和当前结算期内质押金)") @pytest.mark.P2 def test_unstaking_all(self): log.info("转账每个钱包") for to_account in self.account_list: self.transaction(self.w3_list[0], self.address, to_address=to_account) value_before = self.eth.getBalance(self.account_list[5]) log.info(value_before) self.ppos_noconsensus_6.createStaking(0, self.account_list[5], self.nodeid_list2[5], self.externalId, self.nodeName, self.website, self.details, self.amount, self.programVersion) log.info("进入第2个结算周期") get_block_number(self.w3_list[0]) log.info("节点6增持金额") self.ppos_noconsensus_6.addStaking(self.nodeid_list2[5], 0, self.amount + 1000) log.info("进入第3个结算周期") get_block_number(self.w3_list[0]) log.info("节点6发起退回") self.ppos_noconsensus_6.unStaking(nodeId=self.nodeid_list2[5]) log.info("进入第4个结算周期") get_block_number(self.w3_list[0]) value = self.eth.getBalance(self.account_list[5]) log.info(value) assert value < value_before, "钱还在锁定期,预期未退回,实际异常" log.info("进入第5个结算周期") get_block_number(self.w3_list[0]) value_after = self.eth.getBalance(self.account_list[5]) log.info(value_after) log.info(value_after - value_before) amount_sum = self.amount * 2 + 1000 log.info(Web3.toWei(amount_sum, "ether")) assert value_after > value_before, "出块奖励异常" assert value_after > value + Web3.toWei( amount_sum, "ether"), "解锁期的余额大于锁定期的余额+质押+增持金额,但是发生异常" @allure.title("根据金额排名,从高到低排名") @pytest.mark.P0 def test_ranking(self): """ 测试根据金额排名,从高到低排名 """ self.auto = AutoDeployPlaton() self.auto.start_all_node(self.node_yml_path) log.info("转账每个钱包") for to_account in self.account_list: self.transaction(self.w3_list[0], self.address, to_address=to_account) self.ppos_noconsensus_1.createStaking(0, self.account_list[0], self.nodeid_list2[0], self.externalId, self.nodeName, self.website, self.details, self.amount + 50, self.programVersion) self.ppos_noconsensus_2.createStaking(0, self.account_list[1], self.nodeid_list2[1], self.externalId, self.nodeName, self.website, self.details, self.amount + 40, self.programVersion) self.ppos_noconsensus_3.createStaking(0, self.account_list[2], self.nodeid_list2[2], self.externalId, self.nodeName, self.website, self.details, self.amount + 30, self.programVersion) self.ppos_noconsensus_4.createStaking(0, self.account_list[3], self.nodeid_list2[3], self.externalId, self.nodeName, self.website, self.details, self.amount + 20, self.programVersion) self.ppos_noconsensus_5.createStaking(0, self.account_list[4], self.nodeid_list2[4], self.externalId, self.nodeName, self.website, self.details, self.amount + 10, self.programVersion) self.ppos_noconsensus_6.createStaking(0, self.account_list[5], self.nodeid_list2[5], self.externalId, self.nodeName, self.website, self.details, self.amount, self.programVersion) log.info("进入下个周期") get_block_number(self.w3_list[0]) node_list = getVerifierList() log.info(node_list) """根据config配置验证人数""" # assert self.nodeid_list2[5] not in node_list assert node_list[0] == self.nodeid_list2[0] assert node_list[1] == self.nodeid_list2[1] assert node_list[2] == self.nodeid_list2[2] assert node_list[3] == self.nodeid_list2[3] assert node_list[4] == self.nodeid_list2[4] assert node_list[5] == self.nodeid_list2[-1]
class TestDpos: node_yml_path = conf.NODE_YML cbft_json_path = conf.CBFT2 node_info = get_node_info(node_yml_path) rpc_list, enode_list, nodeid_list, ip_list, port_list = node_info.get( 'collusion') rpc_list2, enode_list2, nodeid_list2, ip_list2, port_list2 = node_info.get( 'nocollusion') cbft_dict = LoadFile(cbft_json_path).get_data() address = Web3.toChecksumAddress(conf.ADDRESS) pwd = conf.PASSWORD ticket_price = Web3.fromWei( int(cbft_dict['ppos']['ticket']['ticketPrice']), 'ether') allowed = int(cbft_dict['ppos']['candidate']['allowed']) total_ticket = int(cbft_dict['ppos']['ticket']['maxCount']) rpc_list += rpc_list2 enode_list += enode_list2 nodeid_list += nodeid_list2 ip_list += ip_list2 port_list += port_list2 key_list = ["node" + str(i) for i in range(1, 1 + len(rpc_list))] rpc_dict = dict(zip(key_list, rpc_list)) enode_dict = dict(zip(key_list, enode_list)) nodeid_dict = dict(zip(key_list, nodeid_list)) ip_dict = dict(zip(key_list, ip_list)) port_dict = dict(zip(key_list, port_list)) abi = conf.DPOS_CONTRACT_ABI def setup_class(self): self.auto = AutoDeployPlaton(cbft=self.cbft_json_path) self.auto.start_all_node(self.node_yml_path) self.platon_dpos1 = PlatonDpos( self.rpc_list[0], self.address, self.pwd, abi=self.abi) self.w3_list = [connect_web3(url) for url in self.rpc_list] self.new_address = Web3.toChecksumAddress( self.platon_dpos1.web3.personal.newAccount(self.pwd)) self.send_data = { "to": self.new_address, "from": self.address, "gas": '9000', "gasPrice": '1000000000', "value": self.w3_list[0].toWei(100000, 'ether'), } tx_hash = self.platon_dpos1.eth.sendTransaction(self.send_data) self.platon_dpos1.eth.waitForTransactionReceipt(tx_hash) self.platon_dpos2 = PlatonDpos( self.rpc_list[0], self.new_address, self.pwd, abi=self.abi) self.fee = int(1000).to_bytes(4, 'big') self.extra = "Test" # def teardown_class(self): # self.auto.start_all_node(self.node_yml_path) def check_event(self, msg): event_data, func_name = msg func_name += "Event" assert func_name in event_data, "{}中不包含{}键".format( event_data, func_name) event = event_data[func_name][0] event = json.loads(event) assert event["Ret"], "质押结果状态错误" assert event["ErrMsg"] == "success", "质押结果msg错误" def test_candidate_deposit(self): ''' @Description: 质押节点,使其成为候选人 @param {type} @@@@ @return: @@@@ ''' result = self.platon_dpos1.CandidateDeposit(self.nodeid_dict['node5'], self.new_address, self.fee, self.ip_dict['node5'], self.port_dict['node5'], self.extra, value=100) self.check_event(result) candidate_info = self.platon_dpos1.GetCandidateDetails( self.nodeid_dict['node5']) assert isinstance(candidate_info, dict), "返回结果错误{}".format( candidate_info) assert candidate_info["Deposit"] == self.platon_dpos1.web3.toWei( 100, 'ether') assert candidate_info["Host"] == self.ip_dict["node5"], "质押ip与传输的ip不一致" assert candidate_info["CandidateId"] == self.nodeid_dict["node5"], "质押nodeid与传输的不一致" assert candidate_info["Port"] == self.port_dict['node5'], "质押端口与传输的不一致,获取port:{},实际质押port:{}".format( candidate_info["Port"], self.port_dict['node5']) assert self.platon_dpos1.web3.toChecksumAddress( candidate_info["Owner"]) == self.new_address, "质押地址不正确" candidate_list = self.platon_dpos2.GetCandidateList() # 校验candidate_list包含节点179 assert candidate_info in candidate_list, "候选人列表不包含节点{}".format( self.ip_dict['node5']) # @pytest.mark.skip # def add_pledge(self): # ''' # 已不支持增加质押,用例暂不执行 # 增加质押 # :return: # ''' # result = self.platon_dpos1.CandidateDeposit(self.nodeid_dict['node5'], self.new_address, self.fee, # self.ip_dict['node5'], # self.port_dict['node5'], self.extra, value=10) # self.check_event(result) # candidate_info = self.platon_dpos1.GetCandidateDetails( # self.nodeid_dict['node5']) # # candidate_info为节点179的质押信息 # assert isinstance(candidate_info, dict), "返回结果错误{}".format( # candidate_info) # assert candidate_info["Deposit"] == self.platon_dpos1.web3.toWei( # 60, 'ether') # @pytest.mark.skip # def test_refund_10(self): # ''' # 已不支持部分退款,用例暂不执行 # @Description: 查询退款金额低于10% # @param {type} @@@@ # @return: @@@@ # ''' # i = 500000000000000000 # status = 0 # try: # self.platon_dpos2.CandidateApplyWithdraw( # self.nodeid_dict['node5'], i) # except: # status = 1 # assert status == 1, "低于10%应不允许提取" def test_refund(self): ''' @Description: 查询退款是否正常,是否退出候选人列表 @param {type} @@@@ @return: @@@@ ''' i = 50000000000000000000 start_balance = self.platon_dpos2.eth.getBalance(self.new_address) result = self.platon_dpos2.CandidateDeposit(self.nodeid_dict['node6'], self.new_address, self.fee, self.ip_dict['node6'], self.port_dict['node6'], self.extra, value=50) candidate_info = self.platon_dpos1.GetCandidateDetails( self.nodeid_dict['node6']) self.check_event(result) result = self.platon_dpos2.CandidateApplyWithdraw( self.nodeid_dict['node6'], i) self.check_event(result) time.sleep(3) withdraw_list = self.platon_dpos2.GetCandidateWithdrawInfos( self.nodeid_dict['node6']) assert withdraw_list["Balance"] == i, "申请退款的金额与查询结果不一致" result = self.platon_dpos1.CandidateWithdraw(self.nodeid_dict["node6"]) self.check_event(result) end_balance = self.platon_dpos1.eth.getBalance(self.new_address) assert end_balance - start_balance < 100000000000000000, "退款金额错误,退款前:{}|退款后:{}".format( self.platon_dpos1.web3.fromWei(start_balance, 'ether'), self.platon_dpos1.web3.fromWei(end_balance, 'ether')) candidate_list = self.platon_dpos1.GetCandidateList() assert candidate_info not in candidate_list, "node6还在候选人列表中" def test_candidate_sort(self): ''' @Description: 候选人排序 @param {type} @@@@ @return: @@@@ ''' # result_1 = self.platon_dpos1.CandidateDeposit(self.nodeid_dict['node5'], self.new_address, self.fee, # self.ip_dict['node5'], # self.port_dict['node5'], self.extra, value=45) # self.check_event(result_1) result_2 = self.platon_dpos1.CandidateDeposit(self.nodeid_dict['node6'], self.new_address, self.fee, self.ip_dict['node6'], self.port_dict['node6'], self.extra, value=160) self.check_event(result_2) candidate_list = self.platon_dpos1.GetCandidateList() candidate_info = self.platon_dpos1.GetCandidateDetails( self.nodeid_dict['node6']) assert candidate_list[0] == candidate_info, "候选人列表排序错误" def test_candidate_cap(self): ''' @Description: 候选人列表容量 @param {type} @@@@ @return: @@@@ ''' status = 0 candidate_info = self.platon_dpos1.GetCandidateDetails( self.nodeid_dict['node5']) result_1 = self.platon_dpos1.CandidateDeposit(self.nodeid_dict['node1'], self.new_address, self.fee, self.ip_dict['node1'], self.port_dict['node1'], self.extra, value=131) self.check_event(result_1) result_2 = self.platon_dpos1.CandidateDeposit(self.nodeid_dict['node2'], self.new_address, self.fee, self.ip_dict['node2'], self.port_dict['node2'], self.extra, value=135) self.check_event(result_2) result_3 = self.platon_dpos1.CandidateDeposit(self.nodeid_dict['node3'], self.new_address, self.fee, self.ip_dict['node3'], self.port_dict['node3'], self.extra, value=135) self.check_event(result_3) result_4 = self.platon_dpos1.CandidateDeposit(self.nodeid_dict['node4'], self.new_address, self.fee, self.ip_dict['node4'], self.port_dict['node4'], self.extra, value=140) self.check_event(result_4) candidate_list = self.platon_dpos1.GetCandidateList() log.info("入围节点列表:{}".format(candidate_list)) assert candidate_info not in candidate_list, "node5还在候选人列表中" def test_ticket_price(self): '''校验票价是否与配置文件中一致''' price = self.platon_dpos1.GetTicketPrice() config_price = Web3.toWei(self.ticket_price, 'ether') assert config_price == price, '实际票价:{},与配置文件中:{},不一致'.format( config_price, price) def test_vote_ticket(self): '''投票''' value = self.allowed * self.ticket_price vote_info, _ = self.platon_dpos1.VoteTicket(self.allowed, self.ticket_price, self.nodeid_dict['node6'], self.new_address, value) self.platon_dpos1.VoteTicket(self.allowed, self.ticket_price, self.nodeid_dict['node1'], self.new_address, value) self.platon_dpos1.VoteTicket(self.allowed, self.ticket_price, self.nodeid_dict['node2'], self.new_address, value) self.platon_dpos1.VoteTicket(self.allowed, self.ticket_price, self.nodeid_dict['node3'], self.new_address, value) vote_info, _ = self.platon_dpos1.VoteTicket(self.allowed - 1, self.ticket_price, self.nodeid_dict['node4'], self.new_address, value - 1) assert 'success' in vote_info['VoteTicketEvent'][0], '投票失败,结果:{}'.format( vote_info) # @pytest.skip # def test_ticket_detail(self): # ''' # 接口已经删除,用例屏蔽 # 验证节点下选票数量、选票的详细信息 # ''' # ticket_ids = self.platon_dpos1.GetCandidateTicketIds(self.nodeid_dict['node1']) # ticket_num = len(ticket_ids) # assert ticket_num == self.allowed, '节点选票数:{}与已投票数:{}不一致'.format(ticket_num, self.allowed) # ticket_detail = self.platon_dpos1.GetTicketDetail(ticket_ids[0]) # owner = Web3.toChecksumAddress(ticket_detail[0]['Owner']) # assert owner == self.new_address, '投票人:{}与投票时用的钱包地址:{}不一致'.format(owner, self.new_address) # dposite = ticket_detail[0]['Deposit'] # price = Web3.toWei(self.ticket_price, 'ether') # assert dposite == price, '投票金额:{}与票价:{}不一致'.format(dposite, price) # candidateid = ticket_detail[0]['CandidateId'] # assert candidateid == self.nodeid_dict['node1'], '票详情中节点id:{},与投票时节点id不一致:{}'.format(candidateid, # self.nodeid_dict['node1']) # @pytest.skip # def test_batch_ticket_detail(self): # ''' # 接口已删除,用例屏蔽 # 验证批量获取节点下选票数量、选票的详细信息 # ''' # batch_ticket_ids = self.platon_dpos1.GetBatchCandidateTicketIds( # [self.nodeid_dict['node1'], self.nodeid_dict['node2']]) # print('batch_ticket_ids = ', batch_ticket_ids) # ticket_ids = batch_ticket_ids[0].get(self.nodeid_dict['node1']) # ticket_ids_one = self.platon_dpos1.GetCandidateTicketIds(self.nodeid_dict['node1']) # assert ticket_ids == ticket_ids_one, '批量获取详情{}\n单独获取详情{}不一致'.format(ticket_ids, ticket_ids_one) # node1_tickets = batch_ticket_ids[0].get(self.nodeid_dict['node1']) # node2_tickets = batch_ticket_ids[0].get(self.nodeid_dict['node2']) # ticket_details = self.platon_dpos1.GetBatchTicketDetail([node1_tickets[0], node2_tickets[0]]) # ticket_detail = ticket_details[0] # ticket_detail_one = self.platon_dpos1.GetTicketDetail(ticket_details[0]['TicketId'])[0] # assert ticket_detail == ticket_detail_one, '批量获取的票详情{}与单独查询票详情不一致{}'.format(ticket_detail, ticket_detail_one) # assert len(ticket_details) == 2, '批量获取票详情数{}不等于请求数2'.format(len(ticket_details)) def test_vote_undpos_node(self): '''向非备选池节点投票''' value = self.allowed * self.ticket_price status = 0 try: self.platon_dpos1.VoteTicket(self.allowed, self.ticket_price, self.nodeid_dict['node5'], self.new_address, value) except: status = 1 assert status, '不在备选池的节点不能投票成功' def test_ticket_pool_remainder(self): '''验证票池剩余数量''' remaind = self.platon_dpos1.GetPoolRemainder() should_remaind = self.total_ticket - (self.allowed * 5 - 1) assert remaind == should_remaind, '票池剩余票:{}与已消费后应剩余数:{}不一致'.format( remaind, should_remaind) # @pytest.skip # def test_get_candidate_epoch(self): # ''' # 获取票龄详情接口已删除,无法获取选票产生区块,用例无法验证 # 该接口以后会去掉,用例暂不运行 # 验证候选人票龄 # ''' # ticket_ids = self.platon_dpos1.GetCandidateTicketIds(self.nodeid_dict['node1']) # vote_block_number = self.platon_dpos1.GetTicketDetail(ticket_ids[0])[0]['BlockNumber'] # should_epoch = (self.platon_dpos1.eth.blockNumber - vote_block_number + 1) * len(ticket_ids) # epoch = self.platon_dpos1.GetCandidateEpoch(self.nodeid_dict['node1']) # assert epoch == should_epoch, '候选人票龄计算结果:{},与预期结果:{}不一致'.format(epoch, should_epoch) def test_get_candidate_ticket_count(self): '''批量查询候选节点的有效选票数量''' ctc_dict = self.platon_dpos1.GetCandidateTicketCount( '{}:{}:{}:{}'.format(self.nodeid_dict['node1'], self.nodeid_dict['node2'], self.nodeid_dict['node3'], self.nodeid_dict['node4'])) count1 = int(ctc_dict.get(self.nodeid_dict['node1'])) count2 = int(ctc_dict.get(self.nodeid_dict['node2'])) count3 = int(ctc_dict.get(self.nodeid_dict['node3'])) count4 = int(ctc_dict.get(self.nodeid_dict['node4'])) assert count1 == self.allowed, '候选节点有效选票数量{},与预期结果{}不一致'.format( count1, self.allowed) assert count2 == self.allowed, '候选节点有效选票数量{},与预期结果{}不一致'.format( count2, self.allowed) assert count3 == self.allowed, '候选节点有效选票数量{},与预期结果{}不一致'.format( count3, self.allowed) assert count4 == self.allowed - \ 1, '候选节点有效选票数量{},与预期结果{}不一致'.format(count4, self.allowed) # def test_get_ticket_count_by_tx_hash(self): # '''批量查询交易的有效选票数量''' # _, tx_hash1 = self.platon_dpos1.VoteTicket( # self.allowed, 1, self.nodeid_dict['node1'], self.address, 10) # _, tx_hash2 = self.platon_dpos1.VoteTicket( # self.allowed, 1, self.nodeid_dict['node2'], self.address, 10) # _, tx_hash3 = self.platon_dpos1.VoteTicket( # self.allowed, 1, self.nodeid_dict['node3'], self.address, 10) # _, tx_hash4 = self.platon_dpos1.VoteTicket( # self.allowed, 1, self.nodeid_dict['node4'], self.address, 10) # tc_dict = self.platon_dpos1.GetTicketCountByTxHash( # '{}:{}:{}:{}'.format(tx_hash1, tx_hash2, tx_hash3, tx_hash4)) # assert tc_dict.get(tx_hash1) == self.allowed, '交易的有效选票数量{},与预期结果{}不一致'.format(tc_dict.get(tx_hash1), # self.allowed) # assert tc_dict.get(tx_hash2) == self.allowed, '交易的有效选票数量{},与预期结果{}不一致'.format(tc_dict.get(tx_hash2), # self.allowed) # assert tc_dict.get(tx_hash3) == self.allowed, '交易的有效选票数量{},与预期结果{}不一致'.format(tc_dict.get(tx_hash3), # self.allowed) # assert tc_dict.get(tx_hash4) == self.allowed, '交易的有效选票数量{},与预期结果{}不一致'.format(tc_dict.get(tx_hash4), # self.allowed) def test_verifiers(self): ''' @Description: 验证人为候选人列表的前四,幸运票奖励发放 @param {type} @@@@ @return: @@@@ ''' before_reward = self.platon_dpos1.eth.getBalance(self.new_address) candidate_list = self.platon_dpos1.GetCandidateList() log.info("新的的入围节点列表:{}".format(candidate_list)) candidate_id = [i['CandidateId'] for i in candidate_list] block_number = self.platon_dpos1.eth.blockNumber sleep_time = get_sleep_time(block_number) time.sleep(sleep_time) verfier_info_list = self.platon_dpos1.GetVerifiersList() log.info("验证人列表:{}".format(verfier_info_list)) assert len(verfier_info_list) > 0,"查询结果异常,验证人列表为空。" verfier_list = [info['CandidateId'] for info in verfier_info_list] assert verfier_list == candidate_id[:4], "验证人没有取候选人的前四,验证人id:{}\n候选人id:{}".format(verfier_list, candidate_list[:4]) status = 1 for verfier in verfier_list: if self.nodeid_dict['node4'] in verfier: status = 0 assert status, '投票不达到门槛不能成为见证人' # 校验幸运选票是否发放奖励 after_reward = self.platon_dpos1.eth.getBalance(self.new_address) assert after_reward > before_reward, '见证人奖励未发放,发放前余额:{},发放后余额:{}'.format( before_reward, after_reward) def test_verify_transaction(self): ''' @Description: 切换验证人后,测试交易是否成功,所有节点块高是否一致 @param {type} @@@@ @return: @@@@ ''' tx_hash = self.platon_dpos1.eth.sendTransaction(self.send_data) self.platon_dpos1.eth.waitForTransactionReceipt(tx_hash) block_list = [] for w in self.w3_list: block_list.append(w.eth.blockNumber) assert min(block_list) > 60, "区块没有正常增加" assert max(block_list) - min(block_list) < 5, "各节点区块高度差距过高" time.sleep(60) w3 = Web3(Web3.HTTPProvider(self.rpc_dict["node6"])) assert w3.net.peerCount >= 3, "节点node6连接的节点数少于3个"
""" @Author: wuyiqin @Date: 2019/8/16 11:45 @Description:主要是增持和修改节点信息用例 """ from client_sdk_python import Web3 from common.connect import connect_web3 import json from utils.platon_lib.ppos_wyq import Ppos from conf import setting as conf import time from common import log from common.load_file import LoadFile, get_node_info node_yml_path = conf.PPOS_NODE_YML node_info = get_node_info(node_yml_path) rpc_list, enode_list, nodeid_list, ip_list, port_list = node_info.get( 'collusion') rpc_list2, enode_list2, nodeid_list2, ip_list2, port_list2 = node_info.get( 'nocollusion') address = Web3.toChecksumAddress(conf.ADDRESS) privatekey = conf.PRIVATE_KEY account_list = conf.account_list privatekey_list = conf.privatekey_list genesis_path = conf.GENESIS_TMP genesis_dict = LoadFile(genesis_path).get_data() chainid = int(genesis_dict["config"]["chainId"]) config_json_path = conf.PLATON_CONFIG_PATH