def candidate_has_proposal(clients_noconsensus, all_clients):
clients_noconsensus[0].economic.env.deploy_all()
for client in clients_noconsensus:
address, _ = client.economic.account.generate_account(
client.node.web3, 10**18 * 10000000)
log.info('Node {} staking'.format(client.node.node_id))
result = client.staking.create_staking(0, address, address)
log.info('Node {} staking result: {}'.format(client.node.node_id,
result))
assert_code(result, 0)
client.economic.wait_settlement(client.node)
node_id_list = client.pip.get_candidate_list_not_verifier()
if not node_id_list:
raise Exception('Get candidate list')
verifiers = get_pledge_list(client.ppos.getVerifierList)
log.info('Verifier list : {}'.format(verifiers))
pip = get_client_by_nodeid(verifiers[0], all_clients).pip
result = pip.submitVersion(pip.node.node_id,
str(time.time()),
pip.cfg.version5,
5,
pip.node.staking_address,
transaction_cfg=pip.cfg.transaction_cfg)
log.info('Submit version proposal result : {}'.format(result))
assert_code(result, 0)
return get_client_by_nodeid(node_id_list[0], all_clients).pip
def proposal_pips(all_clients):
'''
get verifier Client object list
:param global_test_env:
:return:
'''
verifier_list = get_pledge_list(all_clients[0].ppos.getVerifierList)
pip = get_client_by_nodeid(verifier_list[0], all_clients).pip
if pip.chain_version != pip.cfg.version0:
pip.economic.env.deploy_all()
if pip.is_exist_effective_proposal():
proposalinfo = pip.get_effect_proposal_info_of_vote()
log.info('proprosalinfo : {}'.format(proposalinfo))
if proposalinfo.get('EndVotingBlock') - pip.node.block_number > 2 * pip.economic.consensus_size \
and proposalinfo.get('NewVersion') == pip.cfg.version5:
verifier_list = get_pledge_list(all_clients[0].ppos.getVerifierList)
log.info('verifierlist{}'.format(verifier_list))
clients_verifier = get_clients_by_nodeid(verifier_list, all_clients)
return [client.pip for client in clients_verifier]
else:
pip.economic.env.deploy_all()
result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 10,
pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
log.info('version proposal result :{}'.format(result))
verifier_list = get_pledge_list(all_clients[0].ppos.getVerifierList)
log.info('verifierlist{}'.format(verifier_list))
clients_verifier = get_clients_by_nodeid(verifier_list, all_clients)
return [client.pip for client in clients_verifier]
def client_candidate(global_running_env, staking_cfg):
"""
Get a candidate node Client object
"""
client_consensus = get_client_consensus(global_running_env, staking_cfg)
all_clients = get_clients(global_running_env, staking_cfg)
clients_noconsensus = get_clients_noconsensus(global_running_env,
staking_cfg)
if not client_consensus.staking.get_candidate_list_not_verifier():
log.info('There is no candidate, node stake')
candidate_list = get_pledge_list(
client_consensus.node.ppos.getCandidateList)
for client in clients_noconsensus:
if client.node.node_id not in candidate_list:
if client.node.program_version != client.pip.cfg.version0:
upload_platon(client.node, client.pip.cfg.PLATON_NEW_BIN0)
client.node.restart()
log.info('Node {} staking'.format(client.node.node_id))
address, _ = client.economic.account.generate_account(
client.node.web3, client.economic.create_staking_limit * 5)
result = client.staking.create_staking(0, address, address)
log.info('Node {} staking result :{}'.format(
client.node.node_id, result))
assert_code(result, 0)
client_consensus.economic.wait_settlement(client_consensus.node)
node_id_list = client_consensus.staking.get_candidate_list_not_verifier()
log.info('Get candidate list no verifier {}'.format(node_id_list))
if len(node_id_list) == 0:
raise Exception('Get candidate list no verifier failed')
return get_client_by_nodeid(node_id_list[0], all_clients)
def test_VE_AD_003(self, new_genesis_env, clients_consensus, all_clients):
submitvpandvote(clients_consensus)
proposalinfo = clients_consensus[
0].pip.get_effect_proposal_info_of_vote()
log.info('Get version proposal information : {}'.format(proposalinfo))
wait_block_number(clients_consensus[0].node,
proposalinfo.get('ActiveBlock'))
consensus_node = new_genesis_env.get_rand_node()
test_node = new_genesis_env.get_a_normal_node()
test_node.clean()
test_node.deploy_me(new_genesis_env.cfg.genesis_tmp)
test_node.admin.addPeer(consensus_node.enode)
time.sleep(5)
assert test_node.web3.net.peerCount > 0, 'Join the chain failed'
assert test_node.block_number > 0, "Non-consensus node sync block failed, block height: {}".format(
test_node.block_number)
time.sleep(5)
client = get_client_by_nodeid(test_node.node_id, all_clients)
address, _ = client.economic.account.generate_account(
client.node.web3, 10**18 * 10000000)
result = client.staking.create_staking(0, address, address)
assert_code(result, 301004)
upload_platon(test_node, client.pip.cfg.PLATON_NEW_BIN)
test_node.restart()
result = client.staking.create_staking(0, address, address)
assert_code(result, 0)
def param_governance_verify(client,
module,
name,
newvalue,
effectiveflag=True):
"""
effectiveflag indicates whether it takes effect
"""
if isinstance(client, Client):
pip = client.pip
else:
raise Exception("client must Client class")
if pip.is_exist_effective_proposal_for_vote(pip.cfg.param_proposal) or \
pip.is_exist_effective_proposal_for_vote(pip.cfg.version_proposal):
raise Exception(
'There is effective param proposal or version proposal')
result = pip.submitParam(pip.node.node_id,
str(time.time()),
module,
name,
newvalue,
pip.node.staking_address,
transaction_cfg=pip.cfg.transaction_cfg)
log.info('submit param proposal result : {}'.format(result))
assert_code(result, 0)
proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal)
log.info('param proposalinfo : {}'.format(proposalinfo))
all_clients = []
for node_obj in pip.economic.env.get_all_nodes():
all_clients.append(
Client(
pip.economic.env, node_obj,
StakingConfig("externalId", "nodeName", "website", "details")))
client = get_client_by_nodeid(pip.node.node_id, all_clients)
verifier_list = get_pledge_list(client.ppos.getVerifierList)
log.info('verifierlist : {}'.format(verifier_list))
clients_verifier = get_clients_by_nodeid(verifier_list, all_clients)
if effectiveflag:
blocknum = 0
for client in clients_verifier:
if client.node.block_number < blocknum and blocknum != 0:
wait_block_number(client.node, blocknum)
result = client.pip.vote(
client.node.node_id,
proposalinfo.get('ProposalID'),
client.pip.cfg.vote_option_yeas,
client.node.staking_address,
transaction_cfg=client.pip.cfg.transaction_cfg)
log.info('Node {} vote proposal result : {}'.format(
client.node.node_id, result))
blocknum = client.node.block_number
wait_block_number(pip.node, proposalinfo.get('EndVotingBlock'))
if effectiveflag:
assert pip.get_status_of_proposal(proposalinfo.get('ProposalID')) == 2
log.info("blockNumber {}, the {} has become {}".format(
proposalinfo.get('EndVotingBlock'), name, newvalue))
else:
assert pip.get_status_of_proposal(proposalinfo.get('ProposalID')) == 3
log.info("{} retains the original value".format(name))
def verifier_node_version(obj, version=None):
if not isinstance(obj, Client):
obj = get_client_by_nodeid(obj.node.node_id, get_clients(obj.economic.env))
node_version = obj.staking.get_version()
log.info('Node {} version is {}'.format(obj.node.node_id, node_version))
if version is None:
return node_version
else:
assert_code(node_version, version)
def submit_param(no_vp_proposal, all_clients):
pip = no_vp_proposal
client = get_client_by_nodeid(pip.node.node_id, all_clients)
newvalue = '1'
if int(get_governable_parameter_value(client, 'slashBlocksReward')) == 1:
newvalue = '2'
result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', newvalue,
pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
log.info('submit param proposal result : {}'.format(result))
assert_code(result, 0)
return pip
def test_VE_AD_001(self, new_genesis_env, all_clients):
consensus_node = new_genesis_env.get_rand_node()
test_node = new_genesis_env.get_a_normal_node()
test_node.clean()
test_node.deploy_me(new_genesis_env.cfg.genesis_tmp)
test_node.admin.addPeer(consensus_node.enode)
time.sleep(5)
assert test_node.web3.net.peerCount > 0, 'Join the chain failed'
assert test_node.block_number > 0, "Non-consensus node sync block failed, block height: {}".format(
test_node.block_number)
time.sleep(5)
client = get_client_by_nodeid(test_node.node_id, all_clients)
address, _ = client.economic.account.generate_account(
client.node.web3, 10**18 * 10000000)
result = client.staking.create_staking(0, address, address)
assert_code(result, 0)
def test_VE_AD_003(self, new_genesis_env, clients_consensus, all_clients):
submitvpandvote(clients_consensus)
proposalinfo = clients_consensus[
0].pip.get_effect_proposal_info_of_vote()
log.info('Get version proposal information : {}'.format(proposalinfo))
wait_block_number(clients_consensus[0].node,
proposalinfo.get('ActiveBlock'))
consensus_node = new_genesis_env.get_rand_node()
test_node = new_genesis_env.get_a_normal_node()
client = get_client_by_nodeid(test_node.node_id, all_clients)
upload_platon(test_node, client.pip.cfg.PLATON_NEW_BIN)
test_node.restart()
test_node.admin.addPeer(consensus_node.enode)
time.sleep(5)
address, _ = client.economic.account.generate_account(
client.node.web3, 10**18 * 10000000)
result = client.staking.create_staking(0, address, address)
assert_code(result, 0)
def test_PP_VO_009_PP_VO_010_V0_TE_001_V0_TE_002(self, submit_param,
all_clients):
pip = submit_param
result = pip.submitText(pip.node.node_id,
str(time.time()),
pip.node.staking_address,
transaction_cfg=pip.cfg.transaction_cfg)
log.info('Submit text proposal result : {}'.format(result))
assert_code(result, 0)
address = pip.node.staking_address
client = get_client_by_nodeid(pip.node.node_id, all_clients)
result = client.staking.withdrew_staking(pip.node.staking_address)
endblock = get_refund_to_account_block(pip)
log.info('Node {} withdrew staking result {}'.format(
pip.node.node_id, result))
assert_code(result, 0)
proposalinfo = pip.get_effect_proposal_info_of_vote(
pip.cfg.param_proposal)
log.info('Cancel proposal info : {}'.format(proposalinfo))
proposalinfo_text = pip.get_effect_proposal_info_of_vote(
pip.cfg.param_proposal)
log.info('Text proposal info : {}'.format(proposalinfo_text))
result = proposal_vote(pip)
assert_code(result, 302020)
result = proposal_vote(pip, proposaltype=pip.cfg.text_proposal)
assert_code(result, 302020)
wait_block_number(pip.node, endblock)
result = pip.vote(pip.node.node_id,
proposalinfo.get('ProposalID'),
pip.cfg.vote_option_nays,
address,
transaction_cfg=pip.cfg.transaction_cfg)
assert_code(result, 302022)
result = pip.vote(pip.node.node_id,
proposalinfo_text.get('ProposalID'),
pip.cfg.vote_option_yeas,
address,
transaction_cfg=pip.cfg.transaction_cfg)
assert_code(result, 302022)
