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]
def test_init_token(self): self.auto = AutoDeployPlaton(cbft=self.cbft_json_path) self.auto.start_all_node(self.node_yml_path) proportion = { 'FOUNDATION': 0.001, 'DEVELOPERS': 0.001, 'INCENTIVEPOOL': 0.001, 'RESERVED': 0.001 } FOUNDATION = self.platon_ppos.eth.getBalance(conf.FOUNDATIONADDRESS) DEVELOPERS = self.platon_ppos.eth.getBalance(conf.DEVELOPERSADDRESS) INCENTIVEPOOL = self.platon_ppos.eth.getBalance( conf.INCENTIVEPOOLADDRESS) RESERVED = self.platon_ppos.eth.getBalance(conf.RESERVEDADDRESS) FOUNDATIONLOCKUP = self.platon_dpos1.eth.getBalance( conf.FOUNDATIONLOCKUPADDRESS) token_init_total = conf.TOKENTOTAL assert (token_init_total * proportion['FOUNDATION']) == (FOUNDATION + FOUNDATIONLOCKUP) assert (token_init_total * proportion['DEVELOPERS']) == DEVELOPERS assert (token_init_total * proportion['INCENTIVEPOOL']) == INCENTIVEPOOL assert (token_init_total * proportion['RESERVED']) == RESERVED assert token_init_total == (FOUNDATION + FOUNDATIONLOCKUP + DEVELOPERS + INCENTIVEPOOL + RESERVED)
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)
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, "出块间隔过大或过小"
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 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]
def setup(node_yml=None): if node_yml: conf.NODE_YML = abspath(node_yml) auto = AutoDeployPlaton(is_metrics=True) # auto.check_node_yml(conf.NODE_YML) # auto.booms(conf.NODE_YML) # auto.deploy_default_yml(conf.NODE_YML) auto.kill_of_yaml(conf.NODE_YML)
def start_init(self): #修改config参数 CommonMethod.update_config(self,'EconomicModel','Common','ExpectedMinutes',3) CommonMethod.update_config(self,'EconomicModel','Common','PerRoundBlocks',10) CommonMethod.update_config(self,'EconomicModel','Common','ValidatorCount',5) CommonMethod.update_config(self,'EconomicModel','Staking','ElectionDistance',20) CommonMethod.update_config(self,'EconomicModel','Staking','StakeThreshold',1000) #启动节点 self.auto = AutoDeployPlaton () self.auto.start_all_node (self.node_yml_path)
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, "区块高度没有增长"
def test_punishment_income(self): ''' 验证低出块率验证节点的处罚金自动转账到激励池 :return: ''' #随机获取其中一个正在出块的节点信息 node_info = get_node_list(conf.TWENTY_FIVENODE_YML) node_info_length = len(node_info) - 1 index = random.randint(0, node_info_length) node_data = node_info[0][index] print(node_data) platon_ppos = Ppos('http://10.10.8.157:6789', self.address, chainid=102, privatekey=conf.PRIVATE_KEY) # platon_ppos = self.ppos_link () incentive_pool_balance_befor = platon_ppos.eth.getBalance( conf.INCENTIVEPOOLADDRESS) log.info('处罚之前激励池查询余额:{}'.format(incentive_pool_balance_befor)) #停止其中一个正在出块的节点信息 try: self.auto = AutoDeployPlaton(cbft=self.cbft_json_path) self.auto.kill(node_data) platon_ppos = self.ppos_link(node_data['url']) if not platon_ppos.web3.isConnected(): platon_ppos = self.ppos_link() current_block = platon_ppos.eth.blockNumber() waiting_time = 250 - (current_block % 250) time.sleep(waiting_time + 1) incentive_pool_balance_after = platon_ppos.eth.getBalance( conf.INCENTIVEPOOLADDRESS) log.info('处罚之后激励池查询余额:{}'.format(incentive_pool_balance_after)) punishment_CandidateInfo = platon_ppos.getCandidateInfo( node_data['id']) if punishment_CandidateInfo['Status'] == 'True': punishment_amount = punishment_CandidateInfo['Data'][ 'Shares'] * (20 / 100) assert incentive_pool_balance_after == incentive_pool_balance_befor + punishment_amount else: log.info("查询处罚节点:{}质押信息失败".format(node_data['host'])) else: log.info("当前质押节点:{}链接正常".format(node_data['host'])) except: status = 1 assert status == 0, '停止节点:{}失败'.format(node_data['host'])
def restart_node(node_list, platon_dpos): auto = AutoDeployPlaton() del node_list[0] del node_list[9] del node_list[0] while True: time.sleep(random.randrange(100, 5000)) verfier_info_list = platon_dpos.GetVerifiersList() num = len(verfier_info_list) if num <= 1: f = 1 else: f = int((num - 1) / 3) + 1 stop_node_list = random.sample(node_list, random.randrange(1, f + 1)) q.put(1) log.info("重启节点:{}".format(stop_node_list)) auto.restart_list(stop_node_list) q.get()
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)
def test_punishment_income(self): ''' 验证低出块率验证节点的处罚金自动转账到激励池 :return: ''' url = CommonMethod.link_list(self) platon_ppos = Ppos(url, self.address, self.chainid) incentive_pool_balance_befor = platon_ppos.eth.getBalance( conf.INCENTIVEPOOLADDRESS) log.info('处罚之前激励池查询余额:{}'.format(incentive_pool_balance_befor)) #获取节点内置质押节点信息 nodeId = CommonMethod.read_out_nodeId(self, 'collusion') log.info("节点ID:{}".format(nodeId)) con_node, no_node = get_node_list(self.node_yml_path) nodes = con_node + no_node for node in nodes: if nodeId in node.values(): node_data = node #获取节点质押金额 punishment_CandidateInfo = platon_ppos.getCandidateInfo(nodeId) assert punishment_CandidateInfo['Status'] == True, "查询锁仓信息失败" pledge_amount1 = punishment_CandidateInfo['Data']['Released'] log.info("质押节点质押金:{}".format(pledge_amount1)) # 停止其中一个正在出块的节点信息 self.auto = AutoDeployPlaton() self.auto.kill(node_data) platon_ppos1 = connect_web3(node_data['url']) assert not platon_ppos1.isConnected(), "节点:{} 连接异常".format( node_data['host']) CommonMethod.get_next_settlement_interval(self) punishment_CandidateInfo = platon_ppos.getCandidateInfo(nodeId) pledge_amount3 = punishment_CandidateInfo['Data']['Released'] log.info("节点低出块率后节点质押金:{}".format(pledge_amount3)) incentive_pool_balance_after = platon_ppos.eth.getBalance( conf.INCENTIVEPOOLADDRESS) log.info('处罚之后激励池查询余额:{}'.format(incentive_pool_balance_after)) assert incentive_pool_balance_after == incentive_pool_balance_befor + ( pledge_amount1 - pledge_amount3)
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 setup(node_yml=None, collusion_number=0): if node_yml: conf.NODE_YML = abspath(node_yml) auto = AutoDeployPlaton() auto.check_node_yml(conf.NODE_YML) conf.NODE_NUMBER = collusion_number auto.start_all_node(conf.NODE_YML)
def stop_node(node_list, platon_dpos): auto = AutoDeployPlaton() del node_list[0] del node_list[9] del node_list[0] while True: time.sleep(random.randrange(100, 5000)) verfier_info_list = platon_dpos.GetVerifiersList() num = len(verfier_info_list) if num <= 1: continue f = int((num - 1) / 3) if f < 2: continue stop_node_list = random.sample(node_list, random.randrange(1, f)) q.put(1) log.info("关闭节点:{}".format(stop_node_list)) number = platon_dpos.web3.eth.blockNumber sleep_time = get_sleep_time(number) auto.kill_of_list(stop_node_list) if sleep_time > 21: time.sleep(random.randrange(1, sleep_time - 20)) log.info("恢复节点:{}".format(stop_node_list)) auto.restart_list(stop_node_list) q.get()
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
def monitor(node_yml): auto = AutoDeployPlaton() collusion, nocollusion = get_node_list(node_yml) node_list = collusion + nocollusion old_block = [0 * i for i in range(len(collusion))] t = 0 while True: time.sleep(120) t += 120 block_list = [] url_list = [] for node in node_list: try: w3 = connect_web3(node["url"]) if not w3.isConnected(): raise Exception("有节点被关闭了") block = w3.eth.blockNumber block_list.append(block) url_list.append(node["url"]) except: close_msg = "节点:{}:{}无法连接\n".format(node["host"], node["port"]) log.warning(close_msg) msg = build_msg(url_list, block_list, old_block) if max(block_list) - min(block_list) >= 100: log.error("区块差距过大") auto.kill_of_yaml(node_yml) send_to_gap(block_list, msg, node_yml) if max(block_list) - min(old_block) == 0: log.error("不出块了") auto.kill_of_yaml(node_yml) send_to_block(msg, node_yml) if t >= 21600: t = 0 send_email(EmailInfo, msg) old_block = block_list
def deploy(node_file): auto = AutoDeployPlaton() auto.deploy_default_yml(node_file)
class TestDposinit: address = conf.ADDRESS pwd = conf.PASSWORD abi = conf.DPOS_CONTRACT_ABI cbft_json_path = conf.CBFT2 node_yml_path = conf.PPOS_NODE_TEST_YML file = conf.CASE_DICT privatekey = conf.PRIVATE_KEY base_gas_price = 60000000000000 base_gas = 21000 staking_gas = base_gas + 32000 + 6000 + 100000 transfer_gasPrice = Web3.toWei(1, 'ether') transfer_gas = 210000000 value = 1000 chainid = 120 ConsensusSize = 150 time_interval = 10 initial_amount = { 'FOUNDATION': 905000000000000000000000000, 'FOUNDATIONLOCKUP': 20000000000000000000000000, 'STAKING': 25000000000000000000000000, 'INCENTIVEPOOL': 45000000000000000000000000, 'DEVELOPERS': 5000000000000000000000000 } def start_init(self): # 修改config参数 CommonMethod.update_config(self, 'EconomicModel', 'Common', 'ExpectedMinutes', 3) CommonMethod.update_config(self, 'EconomicModel', 'Common', 'PerRoundBlocks', 5) CommonMethod.update_config(self, 'EconomicModel', 'Common', 'ValidatorCount', 10) CommonMethod.update_config(self, 'EconomicModel', 'Staking', 'ElectionDistance', 10) CommonMethod.update_config(self, 'EconomicModel', 'Staking', 'StakeThreshold', 1000) # 启动节点 self.auto = AutoDeployPlaton() self.auto.start_all_node(self.node_yml_path) def test_init_token(self): ''' 验证链初始化后token各内置账户初始值 :return: ''' url = CommonMethod.link_list(self) platon_ppos = Ppos(url, self.address, self.chainid) FOUNDATION = platon_ppos.eth.getBalance( Web3.toChecksumAddress(conf.FOUNDATIONADDRESS)) FOUNDATIONLOCKUP = platon_ppos.eth.getBalance( Web3.toChecksumAddress(conf.FOUNDATIONLOCKUPADDRESS)) STAKING = platon_ppos.eth.getBalance( Web3.toChecksumAddress(conf.STAKINGADDRESS)) INCENTIVEPOOL = platon_ppos.eth.getBalance( Web3.toChecksumAddress(conf.INCENTIVEPOOLADDRESS)) DEVELOPERS = platon_ppos.eth.getBalance( Web3.toChecksumAddress(conf.DEVELOPERSADDRESS)) token_init_total = conf.TOKENTOTAL if self.initial_amount['FOUNDATION'] != FOUNDATION: log.info("基金会初始金额:{}有误".format(FOUNDATION)) elif self.initial_amount['FOUNDATIONLOCKUP'] != FOUNDATIONLOCKUP: log.info("基金会锁仓初始金额:{}有误".format(FOUNDATIONLOCKUP)) elif self.initial_amount['STAKING'] != STAKING: log.info("质押账户初始金额:{}有误".format(STAKING)) elif self.initial_amount['INCENTIVEPOOL'] != INCENTIVEPOOL: log.info("奖励池初始金额:{}有误".format(INCENTIVEPOOL)) elif self.initial_amount['DEVELOPERS'] != DEVELOPERS: log.info("预留账户初始金额:{}有误".format(DEVELOPERS)) reality_total = FOUNDATION + FOUNDATIONLOCKUP + STAKING + INCENTIVEPOOL + DEVELOPERS assert token_init_total == ( reality_total), "初始化发行值{}有误".format(reality_total) def test_transfer_normal(self): ''' 验证初始化之后账户之间转账 :return: ''' url = CommonMethod.link_list(self) platon_ppos = Ppos(url, self.address, self.chainid) address1, private_key1 = CommonMethod.read_private_key_list() # 签名转账 result = platon_ppos.send_raw_transaction( '', Web3.toChecksumAddress(self.address), Web3.toChecksumAddress(address1), self.base_gas_price, self.base_gas, self.value, self.privatekey) return_info = platon_ppos.eth.waitForTransactionReceipt(result) assert return_info is not None, "转账:{}失败".format(self.value) balance = platon_ppos.eth.getBalance(address1) log.info("转账金额{}".format(balance)) assert Web3.toWei(self.value, 'ether') == balance, "转账金额:{}失败".format(balance) def test_fee_income(self): ''' 1、验证初始化之后普通账户转账内置账户 2、验证初始内置账户没有基金会Staking奖励和出块奖励只有手续费收益 :return: ''' url = CommonMethod.link_list(self) platon_ppos = Ppos(url, self.address, self.chainid) incentive_pool_balance_befor = platon_ppos.eth.getBalance( conf.INCENTIVEPOOLADDRESS) log.info('交易前激励池查询余额:{}'.format(incentive_pool_balance_befor)) address1, private_key1 = CommonMethod.read_private_key_list() # 签名转账 result = platon_ppos.send_raw_transaction( '', Web3.toChecksumAddress(self.address), Web3.toChecksumAddress(address1), self.base_gas_price, self.base_gas, self.value, self.privatekey) return_info = platon_ppos.eth.waitForTransactionReceipt(result) assert return_info is not None, "转账:{}失败".format(self.value) incentive_pool_balance_after = platon_ppos.eth.getBalance( conf.INCENTIVEPOOLADDRESS) log.info('交易后激励池查询余额:{}'.format(incentive_pool_balance_after)) difference = incentive_pool_balance_after - incentive_pool_balance_befor log.info('手续费的金额:{}'.format(difference)) assert difference == 1260000000000000000, "手续费{}有误".format(difference) def test_punishment_income(self): ''' 验证低出块率验证节点的处罚金自动转账到激励池 :return: ''' url = CommonMethod.link_list(self) platon_ppos = Ppos(url, self.address, self.chainid) incentive_pool_balance_befor = platon_ppos.eth.getBalance( conf.INCENTIVEPOOLADDRESS) log.info('处罚之前激励池查询余额:{}'.format(incentive_pool_balance_befor)) #获取节点内置质押节点信息 nodeId = CommonMethod.read_out_nodeId(self, 'collusion') log.info("节点ID:{}".format(nodeId)) con_node, no_node = get_node_list(self.node_yml_path) nodes = con_node + no_node for node in nodes: if nodeId in node.values(): node_data = node #获取节点质押金额 punishment_CandidateInfo = platon_ppos.getCandidateInfo(nodeId) assert punishment_CandidateInfo['Status'] == True, "查询锁仓信息失败" pledge_amount1 = punishment_CandidateInfo['Data']['Released'] log.info("质押节点质押金:{}".format(pledge_amount1)) # 停止其中一个正在出块的节点信息 self.auto = AutoDeployPlaton() self.auto.kill(node_data) platon_ppos1 = connect_web3(node_data['url']) assert not platon_ppos1.isConnected(), "节点:{} 连接异常".format( node_data['host']) CommonMethod.get_next_settlement_interval(self) punishment_CandidateInfo = platon_ppos.getCandidateInfo(nodeId) pledge_amount3 = punishment_CandidateInfo['Data']['Released'] log.info("节点低出块率后节点质押金:{}".format(pledge_amount3)) incentive_pool_balance_after = platon_ppos.eth.getBalance( conf.INCENTIVEPOOLADDRESS) log.info('处罚之后激励池查询余额:{}'.format(incentive_pool_balance_after)) assert incentive_pool_balance_after == incentive_pool_balance_befor + ( pledge_amount1 - pledge_amount3)
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个"
class TestVC: node_yml = abspath("deploy/node/vc_node.yml") auto = AutoDeployPlaton() def setup_class(self): self.auto.start_all_node(self.node_yml, genesis_file=conf.GENESIS_TMP, static_node_file=conf.STATIC_NODE_FILE) # 等一下,同步块高 collusion, _ = get_node_list(conf.NODE_YML) collusion_w3 = connect_web3(collusion[0]["url"]) collusion_block = collusion_w3.eth.blockNumber _, nocollusion = get_node_list(self.node_yml) self.url = nocollusion[0]['url'] self.ip = nocollusion[0]["host"] self.wt = PlatonContractTransaction(self.url) self.password = conf.PASSWORD nocollusion_block = self.wt.eth.blockNumber if collusion_block - nocollusion_block >= 100: time.sleep(20) elif 100 > collusion_block - nocollusion_block >= 50: time.sleep(10) else: time.sleep(5) addrress = self.wt.w3.toChecksumAddress(conf.ADDRESS) self.wt.w3.personal.unlockAccount(addrress, self.password, 999999) """部署合约""" resp = self.wt.contract_deploy( get_byte_code(abspath('./data/contract/vccMain.wasm')), get_abi_bytes(abspath(r'./data/contract/vccMain.cpp.abi.json')), addrress) result = self.wt.eth.waitForTransactionReceipt(resp) self.contract_address = result['contractAddress'] log.info(self.contract_address) if len(self.wt.eth.getCode(self.contract_address)) < 10: raise Exception("合约部署失败") node = nocollusion[0] ssh, sftp, t = connect_linux(node['host'], username=node['username'], password=node['password']) pwd_list = run_ssh(ssh, "pwd") pwd = pwd_list[0].strip("\r\n") account = 'UTC--2018-10-04T09-02-39.439063439Z--493301712671ada506ba6ca7891f436d29185821' self.wallet_path = '{}/{}/data16789/keystore/{}'.format( pwd, conf.DEPLOY_PATH, account) cmd = '''nohup java -jar ./vc_tool/vctool-1.0.jar > ./vc_tool/nohup.out 2>&1 &''' run_ssh(ssh, cmd) self.get_url = 'http://{}:8112/test/getResult'.format(self.ip) def tearDown(self): self.auto.kill_of_yaml(self.node_yml) def get_transaction_hash(self, value, gas, gasPrice): ''' :return:交易hash ''' url = 'http://{}:8112/test/startVC'.format(self.ip) data = { 'walletPath': self.wallet_path, 'walletPass': self.password, 'contractAddress': self.contract_address, 'input': '20#30', 'value': value, 'gas': gas, 'gasPrice': gasPrice } ret = requests.post(url=url, data=data) hash = ret.text assert hash is not None, '哈希预期返回成功{},实际失败'.format(hash) return hash def get_vc_taskid(self, value=4300000, gas=4300000, gasPrice=22000000000): ''' :return:taskid vc任务号 ''' hash = self.get_transaction_hash(value, gas, gasPrice) url = 'http://{}:8112/test/getTaskIdForHash'.format(self.ip) data = { 'walletPath': self.wallet_path, 'walletPass': self.password, 'contractAddress': self.contract_address, 'hash': hash } ret = requests.post(url=url, data=data) taskid = ret.text assert taskid is not None, 'taskid预期返回成功{},实际失败'.format(taskid) return taskid def test_vc_result_add(self): ''' 获取VC合约add的值 :return: ''' taskid = self.get_vc_taskid() time.sleep(30) data = { 'walletPath': self.wallet_path, 'walletPass': self.password, 'contractAddress': self.contract_address, 'taskId': taskid } ret = requests.post(url=self.get_url, data=data) result = int(ret.text) assert result == 50, '预期结果为50,实际结果为{}'.format(result) assert ret.status_code == 200, '预期返回响应码为200,实际为{}'.format( str(ret.status_code)) def test_value_outsize(self): ''' value过大 :return: ''' taskid = self.get_vc_taskid(value=100000000000000000000000000) time.sleep(30) data = { 'walletPath': self.wallet_path, 'walletPass': self.password, 'contractAddress': self.contract_address, 'taskId': taskid } ret = requests.post(url=self.get_url, data=data) result = int(ret.text) assert result == 0, '预期结果为0,实际结果为{}'.format(result) def test_value_insuff(self): ''' value为0 :return: ''' taskid = self.get_vc_taskid(value=0) time.sleep(30) data = { 'walletPath': self.wallet_path, 'walletPass': self.password, 'contractAddress': self.contract_address, 'taskId': taskid } ret = requests.post(url=self.get_url, data=data) result = int(ret.text) assert result == 50, '预期结果为50,实际结果为{}'.format(result) def test_gas_outsize(self): ''' gas值超过范围内 :return: ''' taskid = self.get_vc_taskid(gas=1000000000000000000) time.sleep(30) data = { 'walletPath': self.wallet_path, 'walletPass': self.password, 'contractAddress': self.contract_address, 'taskId': taskid } status = 0 try: ret = requests.post(url=self.get_url, data=data) assert ret.status_code != 200, '预期返回响应失败,实际为{}'.format( str(ret.status_code)) except: status = 1 assert status == 1, '预期gas过大,返回异常,实际返回成功' def test_gas_insuff(self): ''' gas值过小 :return: ''' taskid = self.get_vc_taskid(gas=10) time.sleep(30) data = { 'walletPath': self.wallet_path, 'walletPass': self.password, 'contractAddress': self.contract_address, 'taskId': taskid } status = 0 try: ret = requests.post(url=self.get_url, data=data) assert ret.status_code != 200, '预期返回响应失败,实际为{}'.format( str(ret.status_code)) except: status = 1 assert status == 1, '预期gas过小,返回异常,实际返回成功'
class CommonMethod(): address = conf.ADDRESS pwd = conf.PASSWORD abi = conf.DPOS_CONTRACT_ABI cbft_json_path = conf.CBFT2 node_yml_path = conf.PPOS_NODE_TEST_YML file = conf.CASE_DICT privatekey = conf.PRIVATE_KEY gasPrice = Web3.toWei(0.000000000000000001, 'ether') gas = 21000 transfer_gasPrice = Web3.toWei(1, 'ether') transfer_gas = 210000000 value = 1000 time_interval = 10 #ConsensusSize = 50 ExpectedMinutes = 180 chainid = 101 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("无可用节点") def get_next_settlement_interval(self, number=1, file=conf.PLATON_CONFIG_PATH): ''' 获取下个结算周期 :param : :return: ''' data = LoadFile(file).get_data() ExpectedMinutes = data['EconomicModel']['Common']['ExpectedMinutes'] Interval = data['EconomicModel']['Common']['Interval'] PerRoundBlocks = data['EconomicModel']['Common']['PerRoundBlocks'] ValidatorCount = data['EconomicModel']['Common']['ValidatorCount'] Consensuswheel = (ExpectedMinutes * 60) // (Interval * PerRoundBlocks * ValidatorCount) ConsensusSize = Consensuswheel * (Interval * PerRoundBlocks * ValidatorCount) ConsensusSize = ConsensusSize * number log.info("结算周期块高:{}".format(ConsensusSize)) url = CommonMethod.link_list(self) platon_ppos = Ppos(url, self.address, self.chainid) current_block = platon_ppos.eth.blockNumber differ_block = ConsensusSize - (current_block % ConsensusSize) current_end_block = current_block + differ_block log.info('当前块高:{} ,下个结算周期结束块高:{}'.format(current_block, current_end_block)) while 1: time.sleep(self.time_interval) current_block = platon_ppos.eth.blockNumber differ_block = ConsensusSize - (current_block % ConsensusSize) log.info('当前块高度:{},还差块高:{}'.format((current_block), differ_block)) if current_block > current_end_block: break def get_next_consensus_wheel(self, number=1, file=conf.PLATON_CONFIG_PATH): ''' 获取下个共识轮 :param : :return: ''' data = LoadFile(file).get_data() Interval = data['EconomicModel']['Common']['Interval'] PerRoundBlocks = data['EconomicModel']['Common']['PerRoundBlocks'] ValidatorCount = data['EconomicModel']['Common']['ValidatorCount'] ConsensusSize = Interval * PerRoundBlocks * ValidatorCount ConsensusSize = ConsensusSize * number url = CommonMethod.link_list(self) platon_ppos = Ppos(url, self.address, self.chainid) current_block = platon_ppos.eth.blockNumber differ_block = ConsensusSize - (current_block % ConsensusSize) current_end_block = current_block + differ_block log.info('当前块高:{} ,下个共识轮周期结束块高:{}'.format(current_block, current_end_block)) while 1: time.sleep(self.time_interval) current_block = platon_ppos.eth.blockNumber differ_block = ConsensusSize - (current_block % ConsensusSize) log.info('当前块高度:{},还差块高:{}'.format((current_block), differ_block)) if current_block > current_end_block: break 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 test(self): self.auto = AutoDeployPlaton() self.auto.start_all_node(self.node_yml_path) # print(self.nodeid_list) def query_blockNumber(self): url = CommonMethod.link_list(self) platon_ppos = Ppos(url, self.address, self.chainid) while 1: current_block = platon_ppos.eth.blockNumber time.sleep(10) print(current_block) def update_config(self, key1, key2, key3=None, value=None, file=conf.PLATON_CONFIG_PATH): ''' 修改config配置参数 :param key1: 第一层级key :param key2: 第二层级key :param key3: 第三层级key :param value: :param file: :return: ''' data = LoadFile(file).get_data() if key3 == None: data[key1][key2] = value else: data[key1][key2][key3] = value data = json.dumps(data) with open(conf.PLATON_CONFIG_PATH, "w") as f: f.write(data) f.close() def read_private_key_list(file=conf.PRIVATE_KEY_LIST): ''' 随机获取一组钱包地址和私钥 :return: ''' with open(file, 'r') as f: private_key_list = f.read().split("\n") index = random.randrange(1, len(private_key_list) - 1) # 生成随机行数 address, private_key = private_key_list[index].split(',') return address, private_key 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 start_init(self): #修改config参数 CommonMethod.update_config(self, 'EconomicModel', 'Common', 'ExpectedMinutes', 3) CommonMethod.update_config(self, 'EconomicModel', 'Common', 'PerRoundBlocks', 10) CommonMethod.update_config(self, 'EconomicModel', 'Common', 'ValidatorCount', 5) CommonMethod.update_config(self, 'EconomicModel', 'Staking', 'ElectionDistance', 20) CommonMethod.update_config(self, 'EconomicModel', 'Staking', 'StakeThreshold', 1000) #启动节点 self.auto = AutoDeployPlaton() self.auto.start_all_node(self.node_yml_path) 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 test(self): self.auto = AutoDeployPlaton() self.auto.start_all_node(self.node_yml_path)
class TestLockeDpositionConfig: address = conf.ADDRESS pwd = conf.PASSWORD abi = conf.DPOS_CONTRACT_ABI cbft_json_path = conf.CBFT2 node_yml_path = conf.PPOS_NODE_TEST_YML file = conf.CASE_DICT privatekey = conf.PRIVATE_KEY base_gas_price = 60000000000000 base_gas = 21000 staking_gas = base_gas + 32000 + 6000 + 100000 transfer_gasPrice = Web3.toWei (1, 'ether') transfer_gas = 210000000 value = 1000 chainid = 120 ConsensusSize = 150 time_interval = 10 initial_amount = {'FOUNDATION': 905000000000000000000000000, 'FOUNDATIONLOCKUP': 20000000000000000000000000, 'STAKING': 25000000000000000000000000, 'INCENTIVEPOOL': 45000000000000000000000000, 'DEVELOPERS': 5000000000000000000000000 } def start_init(self): #修改config参数 CommonMethod.update_config(self,'EconomicModel','Common','ExpectedMinutes',3) CommonMethod.update_config(self,'EconomicModel','Common','PerRoundBlocks',10) CommonMethod.update_config(self,'EconomicModel','Common','ValidatorCount',5) CommonMethod.update_config(self,'EconomicModel','Staking','ElectionDistance',20) CommonMethod.update_config(self,'EconomicModel','Staking','StakeThreshold',1000) #启动节点 self.auto = AutoDeployPlaton () self.auto.start_all_node (self.node_yml_path) def test_unlock_Normal(self): ''' 只有一个锁仓期,到达解锁期返回解锁金额 :param amount: :return: ''' url = CommonMethod.link_list (self) platon_ppos = Ppos (url, self.address, self.chainid) address1, private_key1 = CommonMethod.read_private_key_list () address2, private_key2 = CommonMethod.read_private_key_list () # 签名转账 result = platon_ppos.send_raw_transaction ('', Web3.toChecksumAddress (self.address), Web3.toChecksumAddress (address1), self.base_gas_price, self.base_gas, self.value, self.privatekey) return_info = platon_ppos.eth.waitForTransactionReceipt (result) assert return_info is not None,"转账:{}失败".format(self.value) # 创建锁仓计划 loukupbalace = Web3.toWei (50, 'ether') plan = [{'Epoch': 1, 'Amount': loukupbalace}] result = platon_ppos.CreateRestrictingPlan (address2, plan, privatekey=private_key1, from_address=address1, gasPrice=self.base_gas_price, gas=self.staking_gas) assert result['Status'] == True, "创建锁仓计划返回状态为:{} 有误".format (result['Status']) print(address2) balance = platon_ppos.eth.getBalance(address2) log.info ("锁仓之后账户余额:{}".format (balance)) log.info("当前块高:{}".format(platon_ppos.eth.blockNumber)) RestrictingInfo = platon_ppos.GetRestrictingInfo(address2) assert RestrictingInfo['Status'] == True, "获取锁仓计划返回状态为:{} 有误".format (result['Status']) dict_Info = json.loads(RestrictingInfo['Data']) assert dict_Info['balance'] == loukupbalace,"锁仓金额:{}有误".format(dict_Info['balance']) #验证到达锁仓解锁期之后账户金额 CommonMethod.get_next_settlement_interval(self) balance2 = platon_ppos.eth.getBalance(address2) log.info ("解锁之后账户余额:{}".format (balance2)) RestrictingInfo = platon_ppos.GetRestrictingInfo (address2) assert RestrictingInfo['Status'] == True, "获取锁仓计划返回状态为:{} 有误".format (result['Status']) dict_Info = json.loads (RestrictingInfo['Data']) balance = platon_ppos.eth.getBalance(address2) assert dict_Info['balance'] == 0, "锁仓金额:{}有误".format (dict_Info['balance']) assert balance2 == loukupbalace,"返回的释放锁仓金额:{} 有误".format(balance) def test_multiple_unlock_Normal(self): ''' 多个锁仓期,到达部分解锁期返回解锁金额 :return: ''' url = CommonMethod.link_list (self) platon_ppos = Ppos (url, self.address, self.chainid) address1, private_key1 = CommonMethod.read_private_key_list () address2, private_key2 = CommonMethod.read_private_key_list () # 签名转账 result = platon_ppos.send_raw_transaction ('', Web3.toChecksumAddress (self.address), Web3.toChecksumAddress (address1), self.base_gas_price, self.base_gas, self.value, self.privatekey) return_info = platon_ppos.eth.waitForTransactionReceipt (result) assert return_info is not None,"转账:{}失败".format(self.value) loukupbalace = Web3.toWei (50, 'ether') plan = [{'Epoch': 1, 'Amount': loukupbalace},{'Epoch': 2, 'Amount': loukupbalace}] result = platon_ppos.CreateRestrictingPlan (address2, plan, privatekey=private_key1, from_address=address1, gasPrice=self.base_gas_price, gas=self.staking_gas) assert result['Status'] == True, "创建锁仓计划返回状态为:{} 有误".format (result['Status']) balance = platon_ppos.eth.getBalance (address2) log.info ("锁仓之后账户余额:{}".format (balance)) log.info ("当前块高:{}".format (platon_ppos.eth.blockNumber)) RestrictingInfo = platon_ppos.GetRestrictingInfo (address2) assert RestrictingInfo['Status'] == True, "获取锁仓计划返回状态为:{} 有误".format (result['Status']) dict_Info = json.loads (RestrictingInfo['Data']) assert dict_Info['balance'] == loukupbalace*2, "锁仓金额:{}有误".format (dict_Info['balance']) # 验证到达锁仓第一个解锁期之后账户金额 CommonMethod.get_next_settlement_interval (self) balance2 = platon_ppos.eth.getBalance (address2) log.info ("到达第一个解锁期后账户余额:{}".format (balance2)) RestrictingInfo = platon_ppos.GetRestrictingInfo (address2) assert RestrictingInfo['Status'] == True, "获取锁仓计划返回状态为:{} 有误".format (result['Status']) dict_Info = json.loads (RestrictingInfo['Data']) balance = platon_ppos.eth.getBalance (address2) assert dict_Info['balance'] == loukupbalace, "锁仓金额:{}有误".format (dict_Info['balance']) assert dict_Info['Entry'][0]['amount'] == loukupbalace,"第二个解锁期待释放金额:{}".format(dict_Info['Entry'][0]['amount']) assert balance2 == loukupbalace, "返回的释放锁仓金额:{} 有误".format (balance) #验证到达锁仓第二个解锁期之后账户金额 CommonMethod.get_next_settlement_interval (self) balance3 = platon_ppos.eth.getBalance (address2) log.info ("到达第二个解锁期后账户余额:{}".format (balance2)) RestrictingInfo = platon_ppos.GetRestrictingInfo (address2) assert RestrictingInfo['Status'] == True, "获取锁仓计划返回状态为:{} 有误".format (result['Status']) dict_Info = json.loads (RestrictingInfo['Data']) balance = platon_ppos.eth.getBalance (address2) assert dict_Info['balance'] == 0, "锁仓金额:{}有误".format (dict_Info['balance']) assert balance3 == loukupbalace*2, "返回的释放锁仓金额:{} 有误".format (balance) def test_unlock_point_pledge_amount(self): ''' 到达解锁时间点,锁仓金额质押后在解锁期之后再申请退回质押金 :return: ''' nodeId = CommonMethod.get_no_candidate_list (self) url = CommonMethod.link_list (self) platon_ppos = Ppos (url, self.address, self.chainid) address1, private_key1 = CommonMethod.read_private_key_list () address2, private_key2 = CommonMethod.read_private_key_list () # 签名转账 result = platon_ppos.send_raw_transaction ('', Web3.toChecksumAddress (self.address), Web3.toChecksumAddress (address1), self.base_gas_price, self.base_gas, self.value, self.privatekey) return_info = platon_ppos.eth.waitForTransactionReceipt (result) assert return_info is not None,"转账:{}失败".format(self.value) # 给锁仓账号转手续费 result = platon_ppos.send_raw_transaction ('', Web3.toChecksumAddress (self.address), Web3.toChecksumAddress (address2), self.base_gas_price, self.base_gas, self.value, self.privatekey) return_info = platon_ppos.eth.waitForTransactionReceipt (result) assert return_info is not None, "转账:{}失败".format (self.value) Balance = platon_ppos.eth.getBalance(address1) log.info("{}发起锁仓账户余额:{}".format(address1,Balance)) Balance1 = platon_ppos.eth.getBalance (address1) log.info ("{}发起质押账号余额:{}".format (address2, Balance1)) # 创建锁仓计划 lockupamoutn = 900 loukupbalace = Web3.toWei (lockupamoutn, 'ether') plan = [{'Epoch': 1, 'Amount': loukupbalace}] result = platon_ppos.CreateRestrictingPlan (address2, plan, privatekey=private_key1, from_address=address1, gasPrice=self.base_gas_price, gas=self.staking_gas) assert result['Status'] == True, "创建锁仓计划返回的状态:{},用例失败".format (result['Status']) RestrictingInfo = platon_ppos.GetRestrictingInfo (address2) assert RestrictingInfo['Status'] == True, "查询锁仓计划返回的状态:{},用例失败".format (result['Status']) info = json.loads(RestrictingInfo['Data']) assert info['balance'] == loukupbalace,"锁仓计划可用余额:{},有误".format(info['balance']) balance2 = platon_ppos.eth.getBalance (address1) log.info ("{}创建锁仓后余额:{}".format (address1,balance2)) # 申请质押节点 version = get_version (platon_ppos) amount = 800 result = platon_ppos.createStaking (1, address2, nodeId, 'externalId', 'nodeName', 'website', 'details', amount, version, privatekey=private_key2, from_address=address2, gasPrice=self.base_gas_price, gas=self.staking_gas) assert result['Status'] == True, "申请质押返回的状态:{},{},用例失败".format (result['Status'], result['ErrMsg']) balance3 = platon_ppos.eth.getBalance (address2) log.info ("{}质押完账户余额:{}".format (address2,balance3)) RestrictingInfo = platon_ppos.GetRestrictingInfo (address2) assert RestrictingInfo['Status'] == True, "获取锁仓计划返回状态为:{} 有误".format (result['Status']) dict_Info = json.loads (RestrictingInfo['Data']) assert dict_Info['balance'] == Web3.toWei(lockupamoutn - amount,'ether'), "锁仓金额:{}有误".format (dict_Info['balance']) # 到达解锁期之后锁仓账号余额 CommonMethod.get_next_settlement_interval (self) balance4 = platon_ppos.eth.getBalance (address2) log.info("到达解锁期后预期账户余额:{}".format(balance3 + Web3.toWei(lockupamoutn - amount,'ether'))) log.info("到达解锁期后实际账户余额:{}".format (balance4)) assert balance4 == balance3 + Web3.toWei(lockupamoutn - amount,'ether'),"锁仓账户金额:{} 有误".format(balance4) RestrictingInfo = platon_ppos.GetRestrictingInfo (address2) assert RestrictingInfo['Status'] == True, "获取锁仓计划返回状态为:{} 有误".format (result['Status']) dict_Info = json.loads (RestrictingInfo['Data']) assert dict_Info['balance'] == 0, "锁仓金额:{}有误".format (dict_Info['balance']) assert dict_Info['symbol'] == True,"锁仓的状态:{} 有误".format(dict_Info['symbol']) assert dict_Info['debt'] == Web3.toWei(amount,'ether'),"欠释放锁仓金额:{} 有误".format(dict_Info['debt']) # 申请退回质押金 result = platon_ppos.unStaking (nodeId, privatekey=private_key2, from_address=address2, gasPrice=self.base_gas_price, gas=self.staking_gas) assert result['Status'] == True, "申请质押退回质押金返回的状态:{},用例失败".format (result['Status']) balance5 = platon_ppos.eth.getBalance (address2) log.info ("到达解锁期申请退回质押金后账户余额:{}".format (balance5)) # 等待两个结算周期后查询锁仓账号情况 CommonMethod.get_next_settlement_interval (self,3) RestrictingInfo = platon_ppos.GetRestrictingInfo (address2) balance6 = platon_ppos.eth.getBalance (address2) log.info ("到达解锁期退回质押金后预期账户金额:{}".format (balance5 + loukupbalace)) log.info ("到达解锁期退回质押金后实际账户余额:{}".format (balance6)) assert balance6 == balance5 + loukupbalace, "锁仓账户金额:{} 有误".format (balance6) assert RestrictingInfo['Status'] == True, "获取锁仓计划返回状态为:{} 有误".format (result['Status']) dict_Info = json.loads (RestrictingInfo['Data']) assert dict_Info['balance'] == 0, "锁仓金额:{}有误".format (dict_Info['balance']) assert dict_Info['symbol'] == False, "锁仓的状态:{} 有误".format (dict_Info['symbol']) assert dict_Info['debt'] == 0, "欠释放锁仓金额:{} 有误".format (dict_Info['debt']) def test_unlock_point_delegtion_notbalance(self): ''' 1、到达解锁时间点用锁仓金额去委托节点,到达解锁期账户锁仓不足 2、到达解锁期账户申请部分赎回委托 3、全部赎回委托 :return: ''' nodeId = CommonMethod.get_no_candidate_list (self) url = CommonMethod.link_list (self) platon_ppos = Ppos (url, self.address, self.chainid) address1, private_key1 = CommonMethod.read_private_key_list () address2, private_key2 = CommonMethod.read_private_key_list () # 签名转账 result = platon_ppos.send_raw_transaction ('', Web3.toChecksumAddress (self.address), Web3.toChecksumAddress (address1), self.base_gas_price, self.base_gas, self.value, self.privatekey) return_info = platon_ppos.eth.waitForTransactionReceipt (result) assert return_info is not None, "转账质押账号手续费:{}失败".format (self.value) # 给锁仓账号转手续费 result = platon_ppos.send_raw_transaction ('', Web3.toChecksumAddress (self.address), Web3.toChecksumAddress (address2), self.base_gas_price, self.base_gas, self.value, conf.PRIVATE_KEY) return_info = platon_ppos.eth.waitForTransactionReceipt (result) assert return_info is not None, "转账锁仓账号手续费:{}失败".format (self.value) Balance = platon_ppos.eth.getBalance (address1) log.info ("{}发起锁仓账户余额:{}".format (address1, Balance)) Balance1 = platon_ppos.eth.getBalance (address1) log.info ("{}发起质押账号余额:{}".format (address2, Balance1)) # 申请质押节点 version = get_version (platon_ppos) amount = 100 result = platon_ppos.createStaking (0, address1, nodeId, 'externalId', 'nodeName', 'website', 'details', amount, version, privatekey=private_key1, from_address=address1, gasPrice=self.base_gas_price, gas=self.staking_gas) assert result['Status'] == True, "申请质押返回的状态:{},{},用例失败".format (result['Status'], result['ErrMsg']) Balance2 = platon_ppos.eth.getBalance (address1) log.info ("{}申请质押节点后账户余额:{}".format (address1, Balance2)) # 创建锁仓计划 lockupamoutn = 100 loukupbalace = Web3.toWei (lockupamoutn, 'ether') plan = [{'Epoch': 1, 'Amount': loukupbalace}] result = platon_ppos.CreateRestrictingPlan (address2, plan, privatekey=private_key1, from_address=address1, gasPrice=self.base_gas_price, gas=self.staking_gas) assert result['Status'] == True, "创建锁仓计划返回的状态:{},用例失败".format (result['Status']) RestrictingInfo = platon_ppos.GetRestrictingInfo (address2) assert RestrictingInfo['Status'] == True, "查询锁仓计划返回的状态:{},用例失败".format (result['Status']) dict_Info = json.loads (RestrictingInfo['Data']) assert dict_Info['balance'] == loukupbalace, "锁仓计划金额:{}有误".format (dict_Info['balance']) assert dict_Info['symbol'] == False, "锁仓的状态:{} 有误".format (dict_Info['symbol']) assert dict_Info['debt'] == 0, "欠释放锁仓金额:{} 有误".format (dict_Info['debt']) Balance3 = platon_ppos.eth.getBalance (address1) log.info ("{}创建锁仓计划后账户余额:{}".format (address1, Balance3)) # 申请委托验证人节点 amount = 100 result = platon_ppos.delegate (1, nodeId, amount, privatekey=private_key2, from_address=address2, gasPrice=self.base_gas_price, gas=self.staking_gas) log.info ("申请委托地址:{}".format (address2)) assert result['Status'] == True, "申请委托返回的状态:{},用例失败".format (result['Status']) balance4 = platon_ppos.eth.getBalance (address2) log.info ("{}申请委托验证人节点后账户余额:{}".format (address2,balance4)) # 到达解锁期之后锁仓账号余额 CommonMethod.get_next_settlement_interval (self) balance5 = platon_ppos.eth.getBalance (address2) log.info ("{}到达解锁期后实际账户余额:{}".format (address2,balance5)) assert balance5 == balance4, "锁仓账户金额:{} 有误".format (balance5) RestrictingInfo = platon_ppos.GetRestrictingInfo (address2) assert RestrictingInfo['Status'] == True, "获取锁仓计划返回状态为:{} 有误".format (result['Status']) dict_Info = json.loads (RestrictingInfo['Data']) assert dict_Info['balance'] == 0, "锁仓金额:{}有误".format (dict_Info['balance']) assert dict_Info['symbol'] == True, "锁仓的状态:{} 有误".format (dict_Info['symbol']) assert dict_Info['debt'] == loukupbalace, "欠释放锁仓金额:{} 有误".format (dict_Info['debt']) #申请赎回部分委托金 partamount = 50 msg = platon_ppos.getCandidateInfo (nodeId) stakingBlockNum = msg["Data"]["StakingBlockNum"] delegate_info = platon_ppos.unDelegate (stakingBlockNum, nodeId, partamount, privatekey=private_key2, from_address=address2, gasPrice=self.base_gas_price, gas=self.staking_gas) assert delegate_info['Status'] == True, "申请赎回委托返回的状态:{},用例失败".format (result['Status']) balance6 = platon_ppos.eth.getBalance (address2) log.info ("{}到达解锁期发起赎回部分委托后账户余额:{}".format (address2,balance6)) #到达下个解锁期释放部分委托金 CommonMethod.get_next_settlement_interval (self) balance7 = platon_ppos.eth.getBalance (address2) log.info ("赎回部分委托金后锁仓账户余额:{}".format (balance7)) assert balance7 == balance6 + Web3.toWei (partamount, 'ether'),"到达解锁期赎回部分委托后账户余额:{}".format (balance7) RestrictingInfo = platon_ppos.GetRestrictingInfo (address2) assert RestrictingInfo['Status'] == True, "获取锁仓计划返回状态为:{} 有误".format (result['Status']) dict_Info = json.loads (RestrictingInfo['Data']) assert dict_Info['balance'] == 0, "锁仓金额:{}有误".format (dict_Info['balance']) assert dict_Info['symbol'] == True, "锁仓的状态:{} 有误".format (dict_Info['symbol']) assert dict_Info['debt'] == loukupbalace - Web3.toWei (partamount, 'ether'), "欠释放锁仓金额:{} 有误".format (dict_Info[ 'debt']) #申请赎回全部委托金 delegate_info = platon_ppos.unDelegate (stakingBlockNum, nodeId, lockupamoutn - partamount, privatekey=private_key2, from_address=address2, gasPrice=self.base_gas_price, gas=self.staking_gas) assert delegate_info['Status'] == True, "申请赎回委托返回的状态:{},用例失败".format (result['Status']) balance8 = platon_ppos.eth.getBalance (address2) log.info ("{}赎回全部委托金后锁仓账户余额:{}".format (address2,balance8)) #到达下个解锁期释放全部委托金 CommonMethod.get_next_settlement_interval (self) balance9 = platon_ppos.eth.getBalance (address2) log.info ("{}赎回全部委托金后实际账户余额:{}".format (address2,balance9)) log.info ("{}赎回全部委托金后预期账户余额:{}".format (address2,balance8 + Web3.toWei (lockupamoutn - partamount, 'ether'))) assert balance9 == balance8 + loukupbalace - Web3.toWei (partamount, 'ether'), "到达解锁期赎回委托后账户余额:{}".format (balance9) RestrictingInfo = platon_ppos.GetRestrictingInfo (address2) assert RestrictingInfo['Status'] == True, "获取锁仓计划返回状态为:{} 有误".format (result['Status']) dict_Info = json.loads (RestrictingInfo['Data']) assert dict_Info['balance'] == 0, "锁仓金额:{}有误".format (dict_Info['balance']) assert dict_Info['symbol'] == False, "锁仓的状态:{} 有误".format (dict_Info['symbol']) assert dict_Info['debt'] == 0, "欠释放锁仓金额:{} 有误".format (dict_Info['debt']) def test_unlock_point_pledge_punish_amount(self): ''' 到达解锁期后处罚节点后锁仓账户的余额情况 :return: ''' nodeId = CommonMethod.get_no_candidate_list (self) log.info("质押节点ID:{}".format(nodeId)) url = CommonMethod.link_list (self) platon_ppos = Ppos (url, self.address, self.chainid) address1, private_key1 = CommonMethod.read_private_key_list () address2, private_key2 = CommonMethod.read_private_key_list () # 给发起锁仓账户转手续费 result = platon_ppos.send_raw_transaction ('', Web3.toChecksumAddress (self.address), Web3.toChecksumAddress (address1), self.base_gas_price, self.base_gas, self.value, self.privatekey) return_info = platon_ppos.eth.waitForTransactionReceipt (result) assert return_info is not None, "转账:{}失败".format (self.value) # 给发起质押账号转手续费 result = platon_ppos.send_raw_transaction ('', Web3.toChecksumAddress (self.address), Web3.toChecksumAddress (address2), self.base_gas_price, self.base_gas, self.value, self.privatekey) return_info = platon_ppos.eth.waitForTransactionReceipt (result) assert return_info is not None, "转账:{}失败".format (self.value) Balance = platon_ppos.eth.getBalance (address1) log.info ("{}账户余额:{}".format (address1, Balance)) Balance1 = platon_ppos.eth.getBalance (address1) log.info ("{}账号余额:{}".format (address2, Balance1)) # 创建锁仓计划 lockupamoutn = 900 loukupbalace = Web3.toWei (lockupamoutn, 'ether') plan = [{'Epoch': 3, 'Amount': loukupbalace}] result = platon_ppos.CreateRestrictingPlan (address2, plan, privatekey=private_key1, from_address=address1, gasPrice=self.base_gas_price, gas=self.staking_gas) assert result['Status'] == True, "创建锁仓计划返回的状态:{},用例失败".format (result['Status']) RestrictingInfo = platon_ppos.GetRestrictingInfo (address2) assert RestrictingInfo['Status'] == True, "查询锁仓计划返回的状态:{},用例失败".format (result['Status']) Balance2 = platon_ppos.eth.getBalance (address1) log.info ("{}发起锁仓后账户余额:{}".format (address1, Balance2)) # 申请质押节点 version = get_version (platon_ppos) amount = 900 result = platon_ppos.createStaking (1, address2, nodeId, 'externalId', 'nodeName', 'website', 'details', amount, version, privatekey=private_key2, from_address=address2, gasPrice=self.base_gas_price, gas=self.staking_gas) assert result['Status'] == True, "申请质押返回的状态:{},{},用例失败".format (result['Status'], result['ErrMsg']) platon_ppos.GetRestrictingInfo(address2) result = platon_ppos.getCandidateInfo(nodeId) assert result['Status'] == True, "获取质押节点返回状态为:{} 有误".format (result['Status']) RestrictingPlan = result['Data']['RestrictingPlanHes'] assert RestrictingPlan == Web3.toWei (amount, 'ether'),'质押金额:{} 有误'.format(RestrictingPlan) Balance3 = platon_ppos.eth.getBalance (address2) log.info ("{}质押完锁仓账户余额:{}".format (address2,Balance3)) #等待验证人加入共识出块节点 CommonMethod.get_next_settlement_interval (self,1) Balance4 = platon_ppos.eth.getBalance (address2) log.info ("{}加入共识验证人后账户余额:{}".format (address2, Balance4)) # 获取节点内置质押节点信息 con_node, no_node = get_node_list (self.node_yml_path) nodes = con_node + no_node for node in nodes: if nodeId in node.values (): node_data = node log.info("{}质押节点信息:{}".format(address2,node_data)) #停止质押节点 self.auto = AutoDeployPlaton () self.auto.kill (node_data) platon_ppos1 = connect_web3 (node_data['url']) assert not platon_ppos1.isConnected(),"节点:{} 连接异常".format(node_data['host']) # 到达解锁期后处罚节点后锁仓账户 CommonMethod.get_next_settlement_interval (self,1) Balance5 = platon_ppos.eth.getBalance (address2) log.info ("{}到达解锁期后处罚节点后预期账户余额:{}".format (address2,Balance4 + Web3.toWei (amount-(amount * 0.2), 'ether'))) log.info ("{}到达解锁期后处罚节点后实际账户余额:{}".format (address2,Balance5)) result = platon_ppos.getCandidateInfo(nodeId) assert Balance5 == Balance4 + Web3.toWei (amount-(amount * 0.2), 'ether'), "锁仓账户金额:{} 有误".format (Balance4) RestrictingInfo = platon_ppos.GetRestrictingInfo (address2) assert RestrictingInfo['Status'] == True, "获取锁仓计划返回状态为:{} 有误".format (result['Status']) dict_Info = json.loads (RestrictingInfo['Data']) assert dict_Info['balance'] == 0, "锁仓计划可用金额:{}有误".format (dict_Info['balance']) assert dict_Info['symbol'] == True, "欠释放状态:{} 有误".format (dict_Info['symbol']) assert dict_Info['debt'] == Web3.toWei (amount-(amount * 0.2), 'ether'), "欠释放锁仓金额:{} 有误".format (dict_Info['debt']) def test_eliminated_verifier_create_lockup(self): ''' 验证人违规被剔除验证人列表,申请质押节点 :return: ''' nodeId = CommonMethod.get_no_candidate_list (self) url = CommonMethod.link_list (self) platon_ppos = Ppos (url, self.address, self.chainid) address1, private_key1 = CommonMethod.read_private_key_list () # 签名转账 result = platon_ppos.send_raw_transaction ('', Web3.toChecksumAddress (self.address), Web3.toChecksumAddress (address1), self.base_gas_price, self.base_gas, self.value, self.privatekey) return_info = platon_ppos.eth.waitForTransactionReceipt (result) assert return_info is not None, "转账:{}失败".format (self.value) balance = platon_ppos.eth.getBalance (address1) log.info ("{}发起锁仓账户余额:{}".format (address1,balance)) # 创建锁仓计划 lockupamoutn = 900 loukupbalace = Web3.toWei (lockupamoutn, 'ether') plan = [{'Epoch': 5, 'Amount': loukupbalace}] result = platon_ppos.CreateRestrictingPlan (address1, plan, privatekey=private_key1, from_address=address1, gasPrice=self.base_gas_price, gas=self.staking_gas) assert result['Status'] == True, "创建锁仓计划返回的状态:{},用例失败".format (result['Status']) RestrictingInfo = platon_ppos.GetRestrictingInfo (address1) assert RestrictingInfo['Status'] == True, "查询锁仓计划返回的状态:{},用例失败".format (result['Status']) # 申请质押节点 version = get_version (platon_ppos) amount = 200 result = platon_ppos.createStaking (1, address1, nodeId, 'externalId', 'nodeName', 'website', 'details', amount, version, privatekey=private_key1, from_address=address1, gasPrice=self.base_gas_price, gas=self.staking_gas) assert result['Status'] == True, "申请质押返回的状态:{},{},用例失败".format (result['Status'], result['ErrMsg']) result = platon_ppos.getCandidateInfo(nodeId) log.info("质押节点信息:{}".format(result)) # 等待成为共识验证人 CommonMethod.get_next_settlement_interval (self) CandidateInfo = platon_ppos.getCandidateInfo(nodeId) log.info("验证人信息{}".format(CandidateInfo)) VerifierList = platon_ppos.getVerifierList () log.info ("当前验证人列表:{}".format (VerifierList)) ValidatorList = platon_ppos.getValidatorList() log.info("当前共识验证人列表:{}".format(ValidatorList)) # for dictinfo in CandidateInfo['Data']: # if nodeId == dictinfo['NodeId']: # log.info("节点id:{}已成为共识验证人".format(nodeId)) # break # else: # log.info("节点id:{}未成为共识验证人".format(nodeId)) # status=0 # assert status == 1 # 获取节点内置质押节点信息 con_node, no_node = get_node_list (self.node_yml_path) nodes = con_node + no_node for node in nodes: if nodeId in node.values (): node_data = node # 停止其中一个正在出块的节点信息 self.auto = AutoDeployPlaton () self.auto.kill (node_data) platon_ppos1 = connect_web3 (node_data['url']) assert not platon_ppos1.isConnected (), "节点:{} 连接异常".format (node_data['host']) # 等待节点被剔除验证人列表 CommonMethod.get_next_consensus_wheel (self,2) # 申请质押节点 version = get_version (platon_ppos) amount = 200 result = platon_ppos.createStaking (1, address1, nodeId, 'externalId', 'nodeName', 'website', 'details', amount, version, privatekey=private_key1, from_address=address1, gasPrice=self.base_gas_price, gas=self.staking_gas) assert result['Status'] == False, "申请质押返回的状态:{},用例失败".format (result['Status']) def test_owe_amountstack_lock_plan(self): ''' 到达解锁时间点,如果账户锁仓不足再新增新的锁仓计划 :return: ''' nodeId = CommonMethod.get_no_candidate_list (self) url = CommonMethod.link_list (self) platon_ppos = Ppos (url, self.address, self.chainid) address1, private_key1 = CommonMethod.read_private_key_list () address2, private_key2 = CommonMethod.read_private_key_list () # 签名转账 result = platon_ppos.send_raw_transaction ('', Web3.toChecksumAddress (self.address), Web3.toChecksumAddress (address1), self.base_gas_price, self.base_gas, self.value, self.privatekey) return_info = platon_ppos.eth.waitForTransactionReceipt (result) assert return_info is not None, "转账:{}失败".format (self.value) # 创建锁仓计划 lockupamoutn = 500 loukupbalace = Web3.toWei (lockupamoutn, 'ether') plan = [{'Epoch': 1, 'Amount': loukupbalace}] result = platon_ppos.CreateRestrictingPlan (address2, plan, privatekey=private_key1, from_address=address1, gasPrice=self.base_gas_price, gas=self.staking_gas) assert result['Status'] == True, "创建锁仓计划返回的状态:{},用例失败".format (result['Status']) RestrictingInfo = platon_ppos.GetRestrictingInfo (address2) assert RestrictingInfo['Status'] == True, "查询锁仓计划返回的状态:{},用例失败".format (result['Status']) # 给锁仓账号转手续费 result = platon_ppos.send_raw_transaction ('', Web3.toChecksumAddress (self.address), Web3.toChecksumAddress (address2), self.base_gas_price, self.base_gas, self.value, self.privatekey) return_info = platon_ppos.eth.waitForTransactionReceipt (result) assert return_info is not None, "转账:{}失败".format (self.value) balance = platon_ppos.eth.getBalance(address2) log.info("锁仓账户余额:{}".format(balance)) # 申请质押节点 version = get_version (platon_ppos) amount = 500 result = platon_ppos.createStaking (1, address2, nodeId, 'externalId', 'nodeName', 'website', 'details', amount, version, privatekey=private_key2, from_address=address2, gasPrice=self.base_gas_price, gas=self.staking_gas) assert result['Status'] == True, "申请质押返回的状态:{},{},用例失败".format (result['Status'], result['ErrMsg']) #到达解锁期释放锁仓金额 CommonMethod.get_next_settlement_interval (self) platon_ppos.GetRestrictingInfo(address2) balance = platon_ppos.eth.getBalance(address2) log.info("到达解锁期释放锁仓余额:{}".format(balance)) # 创建锁仓计划 lockupamoutn = 100 loukupbalace = Web3.toWei (lockupamoutn, 'ether') plan = [{'Epoch': 1, 'Amount': loukupbalace}] result = platon_ppos.CreateRestrictingPlan (address2, plan, privatekey=private_key1, from_address=address1, gasPrice=self.base_gas_price, gas=self.staking_gas) assert result['Status'] == True, "创建锁仓计划返回的状态:{},用例失败".format (result['Status']) RestrictingInfo = platon_ppos.GetRestrictingInfo (address2) assert RestrictingInfo['Status'] == True, "查询锁仓计划返回的状态:{},用例失败".format (result['Status']) dict_Info = json.loads (RestrictingInfo['Data']) assert dict_Info['balance'] == Web3.toWei (100, 'ether'), "锁仓金额:{}有误".format (dict_Info['balance']) assert dict_Info['symbol'] == True, "锁仓的状态:{} 有误".format (dict_Info['symbol']) assert dict_Info['debt'] == Web3.toWei (500, 'ether'), "欠释放锁仓金额:{} 有误".format (dict_Info['debt']) def testss(self): url = CommonMethod.link_list (self) platon_ppos = Ppos (url, self.address, self.chainid) while 1: block = platon_ppos.eth.blockNumber print(block)
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)
def test_unlock_point_pledge_punish_amount(self): ''' 到达解锁期后处罚节点后锁仓账户的余额情况 :return: ''' nodeId = CommonMethod.get_no_candidate_list (self) log.info("质押节点ID:{}".format(nodeId)) url = CommonMethod.link_list (self) platon_ppos = Ppos (url, self.address, self.chainid) address1, private_key1 = CommonMethod.read_private_key_list () address2, private_key2 = CommonMethod.read_private_key_list () # 给发起锁仓账户转手续费 result = platon_ppos.send_raw_transaction ('', Web3.toChecksumAddress (self.address), Web3.toChecksumAddress (address1), self.base_gas_price, self.base_gas, self.value, self.privatekey) return_info = platon_ppos.eth.waitForTransactionReceipt (result) assert return_info is not None, "转账:{}失败".format (self.value) # 给发起质押账号转手续费 result = platon_ppos.send_raw_transaction ('', Web3.toChecksumAddress (self.address), Web3.toChecksumAddress (address2), self.base_gas_price, self.base_gas, self.value, self.privatekey) return_info = platon_ppos.eth.waitForTransactionReceipt (result) assert return_info is not None, "转账:{}失败".format (self.value) Balance = platon_ppos.eth.getBalance (address1) log.info ("{}账户余额:{}".format (address1, Balance)) Balance1 = platon_ppos.eth.getBalance (address1) log.info ("{}账号余额:{}".format (address2, Balance1)) # 创建锁仓计划 lockupamoutn = 900 loukupbalace = Web3.toWei (lockupamoutn, 'ether') plan = [{'Epoch': 3, 'Amount': loukupbalace}] result = platon_ppos.CreateRestrictingPlan (address2, plan, privatekey=private_key1, from_address=address1, gasPrice=self.base_gas_price, gas=self.staking_gas) assert result['Status'] == True, "创建锁仓计划返回的状态:{},用例失败".format (result['Status']) RestrictingInfo = platon_ppos.GetRestrictingInfo (address2) assert RestrictingInfo['Status'] == True, "查询锁仓计划返回的状态:{},用例失败".format (result['Status']) Balance2 = platon_ppos.eth.getBalance (address1) log.info ("{}发起锁仓后账户余额:{}".format (address1, Balance2)) # 申请质押节点 version = get_version (platon_ppos) amount = 900 result = platon_ppos.createStaking (1, address2, nodeId, 'externalId', 'nodeName', 'website', 'details', amount, version, privatekey=private_key2, from_address=address2, gasPrice=self.base_gas_price, gas=self.staking_gas) assert result['Status'] == True, "申请质押返回的状态:{},{},用例失败".format (result['Status'], result['ErrMsg']) platon_ppos.GetRestrictingInfo(address2) result = platon_ppos.getCandidateInfo(nodeId) assert result['Status'] == True, "获取质押节点返回状态为:{} 有误".format (result['Status']) RestrictingPlan = result['Data']['RestrictingPlanHes'] assert RestrictingPlan == Web3.toWei (amount, 'ether'),'质押金额:{} 有误'.format(RestrictingPlan) Balance3 = platon_ppos.eth.getBalance (address2) log.info ("{}质押完锁仓账户余额:{}".format (address2,Balance3)) #等待验证人加入共识出块节点 CommonMethod.get_next_settlement_interval (self,1) Balance4 = platon_ppos.eth.getBalance (address2) log.info ("{}加入共识验证人后账户余额:{}".format (address2, Balance4)) # 获取节点内置质押节点信息 con_node, no_node = get_node_list (self.node_yml_path) nodes = con_node + no_node for node in nodes: if nodeId in node.values (): node_data = node log.info("{}质押节点信息:{}".format(address2,node_data)) #停止质押节点 self.auto = AutoDeployPlaton () self.auto.kill (node_data) platon_ppos1 = connect_web3 (node_data['url']) assert not platon_ppos1.isConnected(),"节点:{} 连接异常".format(node_data['host']) # 到达解锁期后处罚节点后锁仓账户 CommonMethod.get_next_settlement_interval (self,1) Balance5 = platon_ppos.eth.getBalance (address2) log.info ("{}到达解锁期后处罚节点后预期账户余额:{}".format (address2,Balance4 + Web3.toWei (amount-(amount * 0.2), 'ether'))) log.info ("{}到达解锁期后处罚节点后实际账户余额:{}".format (address2,Balance5)) result = platon_ppos.getCandidateInfo(nodeId) assert Balance5 == Balance4 + Web3.toWei (amount-(amount * 0.2), 'ether'), "锁仓账户金额:{} 有误".format (Balance4) RestrictingInfo = platon_ppos.GetRestrictingInfo (address2) assert RestrictingInfo['Status'] == True, "获取锁仓计划返回状态为:{} 有误".format (result['Status']) dict_Info = json.loads (RestrictingInfo['Data']) assert dict_Info['balance'] == 0, "锁仓计划可用金额:{}有误".format (dict_Info['balance']) assert dict_Info['symbol'] == True, "欠释放状态:{} 有误".format (dict_Info['symbol']) assert dict_Info['debt'] == Web3.toWei (amount-(amount * 0.2), 'ether'), "欠释放锁仓金额:{} 有误".format (dict_Info['debt'])
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))
def test_eliminated_verifier_create_lockup(self): ''' 验证人违规被剔除验证人列表,申请质押节点 :return: ''' nodeId = CommonMethod.get_no_candidate_list (self) url = CommonMethod.link_list (self) platon_ppos = Ppos (url, self.address, self.chainid) address1, private_key1 = CommonMethod.read_private_key_list () # 签名转账 result = platon_ppos.send_raw_transaction ('', Web3.toChecksumAddress (self.address), Web3.toChecksumAddress (address1), self.base_gas_price, self.base_gas, self.value, self.privatekey) return_info = platon_ppos.eth.waitForTransactionReceipt (result) assert return_info is not None, "转账:{}失败".format (self.value) balance = platon_ppos.eth.getBalance (address1) log.info ("{}发起锁仓账户余额:{}".format (address1,balance)) # 创建锁仓计划 lockupamoutn = 900 loukupbalace = Web3.toWei (lockupamoutn, 'ether') plan = [{'Epoch': 5, 'Amount': loukupbalace}] result = platon_ppos.CreateRestrictingPlan (address1, plan, privatekey=private_key1, from_address=address1, gasPrice=self.base_gas_price, gas=self.staking_gas) assert result['Status'] == True, "创建锁仓计划返回的状态:{},用例失败".format (result['Status']) RestrictingInfo = platon_ppos.GetRestrictingInfo (address1) assert RestrictingInfo['Status'] == True, "查询锁仓计划返回的状态:{},用例失败".format (result['Status']) # 申请质押节点 version = get_version (platon_ppos) amount = 200 result = platon_ppos.createStaking (1, address1, nodeId, 'externalId', 'nodeName', 'website', 'details', amount, version, privatekey=private_key1, from_address=address1, gasPrice=self.base_gas_price, gas=self.staking_gas) assert result['Status'] == True, "申请质押返回的状态:{},{},用例失败".format (result['Status'], result['ErrMsg']) result = platon_ppos.getCandidateInfo(nodeId) log.info("质押节点信息:{}".format(result)) # 等待成为共识验证人 CommonMethod.get_next_settlement_interval (self) CandidateInfo = platon_ppos.getCandidateInfo(nodeId) log.info("验证人信息{}".format(CandidateInfo)) VerifierList = platon_ppos.getVerifierList () log.info ("当前验证人列表:{}".format (VerifierList)) ValidatorList = platon_ppos.getValidatorList() log.info("当前共识验证人列表:{}".format(ValidatorList)) # for dictinfo in CandidateInfo['Data']: # if nodeId == dictinfo['NodeId']: # log.info("节点id:{}已成为共识验证人".format(nodeId)) # break # else: # log.info("节点id:{}未成为共识验证人".format(nodeId)) # status=0 # assert status == 1 # 获取节点内置质押节点信息 con_node, no_node = get_node_list (self.node_yml_path) nodes = con_node + no_node for node in nodes: if nodeId in node.values (): node_data = node # 停止其中一个正在出块的节点信息 self.auto = AutoDeployPlaton () self.auto.kill (node_data) platon_ppos1 = connect_web3 (node_data['url']) assert not platon_ppos1.isConnected (), "节点:{} 连接异常".format (node_data['host']) # 等待节点被剔除验证人列表 CommonMethod.get_next_consensus_wheel (self,2) # 申请质押节点 version = get_version (platon_ppos) amount = 200 result = platon_ppos.createStaking (1, address1, nodeId, 'externalId', 'nodeName', 'website', 'details', amount, version, privatekey=private_key1, from_address=address1, gasPrice=self.base_gas_price, gas=self.staking_gas) assert result['Status'] == False, "申请质押返回的状态:{},用例失败".format (result['Status'])
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