def __init__(self, URL):
self.URL = URL
self.w3 = connect_web3(URL)
self.eth = Eth(self.w3)
self.personal = Personal(self.w3)
for i in range(5):
if self.w3.isConnected():
break
else:
self.w3 = connect_web3(URL)
time.sleep(1)
else:
raise Exception("节点连接失败")
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 setup_module():
collusion_list_p2p, _ = generate_init_node(collusion_list)
for node in nocollusion_list:
w3 = connect_web3(node["url"])
for p2p in collusion_list_p2p:
w3.admin.addPeer(p2p)
time.sleep(10)
def test_money_insufficient_transaction():
'''
余额不足，转账失败
:return:
'''
collusion_w3 = connect_web3(collusion_list[0]["url"])
new_account = collusion_w3.personal.newAccount(conf.PASSWORD)
from_account = collusion_w3.toChecksumAddress(conf.ADDRESS)
to_account = collusion_w3.toChecksumAddress(new_account)
collusion_w3.personal.unlockAccount(from_account, conf.PASSWORD, 666666)
# 先给新建的钱包充钱1000000000000000000000
transaction(collusion_w3, from_account, to_account)
# 新建另一个钱包
new_account_ = collusion_w3.toChecksumAddress(
collusion_w3.personal.newAccount(conf.PASSWORD))
before_value = collusion_w3.eth.getBalance(to_account)
status = 0
try:
# 转账到新的钱包，金额大于余额，应报异常
transaction(collusion_w3,
to_account,
new_account_,
value=9000000000000000000000000000)
except:
status = 1
assert status == 1, '余额不足预期结果交易失败，实际结果出现异常'
after_value = collusion_w3.eth.getBalance(to_account)
assert after_value - before_value == 0, '余额不足，预期结果钱未转出去，实际结果异常'
def test_new_account_transaction():
'''
新建账号存在余额后转账给其他账号
'''
nocollusion_w3 = connect_web3(nocollusion_list[0]["url"])
eth = Eth(nocollusion_w3)
# 先给新账户存钱
new_account = nocollusion_w3.toChecksumAddress(
nocollusion_w3.personal.newAccount(conf.PASSWORD))
from_account = nocollusion_w3.toChecksumAddress(conf.ADDRESS)
nocollusion_w3.personal.unlockAccount(from_account, conf.PASSWORD, 666666)
trans_hex = transaction(nocollusion_w3, from_account, new_account)
eth.waitForTransactionReceipt(HexBytes(trans_hex).hex())
# 新账户把钱转给其他账户
new_account2 = nocollusion_w3.toChecksumAddress(
nocollusion_w3.personal.newAccount(conf.PASSWORD))
before_value = eth.getBalance(new_account2)
nocollusion_w3.personal.unlockAccount(new_account, conf.PASSWORD, 666666)
trans_hex2 = transaction(nocollusion_w3,
new_account,
new_account2,
value=100)
eth.waitForTransactionReceipt(HexBytes(trans_hex2).hex())
after_value = eth.getBalance(new_account2)
assert after_value - before_value == 100, '交易失败，转账金额未到账'
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_start_2f_after_all(t):
"""
用例id:63,64,65
先启动2f个节点，间隔一定时间之后再启动未启动的所有共识节点，查看出块情况
"""
num = int(2 * f)
log.info("先启动{}个节点".format(num))
auto.start_of_list(collusion_list[0:num],
genesis_file=genesis_file,
static_node_file=static_node_file)
time.sleep(4)
log.info("跟所有节点建立连接")
w3_list = [connect_web3(url) for url in url_list[0:num]]
log.info("查询所有节点块高")
block_list = [w3.eth.blockNumber for w3 in w3_list]
log.info("所有节点块高：{}".format(block_list))
max_value = max(block_list)
assert max_value == 0, "启动{}个节点就开始出块了".format(num)
log.info("sleep {}s".format(t))
time.sleep(int(t))
log.info("在启动另外所有共识节点")
auto.start_of_list(collusion_list[num:],
genesis_file=genesis_file,
static_node_file=static_node_file)
check_blocknumber(url_list, (n - 1) * 10, n)
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_up2f_after_other(x):
"""
用例id:61,62
"""
num = int(2 * f)
log.info("先启动{}个节点".format(num))
auto.start_of_list(collusion_list[0:num],
genesis_file=genesis_file,
static_node_file=static_node_file)
time.sleep(4)
log.info("跟所有节点建立连接")
w3_list = [connect_web3(url) for url in url_list[0:num]]
log.info("查询所有节点块高")
block_list = [w3.eth.blockNumber for w3 in w3_list]
log.info("所有节点块高：{}".format(block_list))
auto.start_of_list(collusion_list[num:num + x],
genesis_file=genesis_file,
static_node_file=static_node_file)
i = 0
while i <= 30:
auto.kill_of_list(collusion_list[num:num + x])
auto.start_of_list(collusion_list[num:num + x], is_need_init=False)
time.sleep(5)
i += 5
check_blocknumber(url_list[:num + x], (num + x - 2) * 10, n)
def test_deconsensus_block_synchronize(self):
'''
非共识节点块高同步
'''
w3 = connect_web3(self.one_collusion_url)
log.info(w3.net.peerCount)
block_number = w3.eth.blockNumber
assert block_number > 0, "非共识节点同步区块失败，块高：{}".format(block_number)
def __init__(self, url, address, password, privatekey=conf.PRIVATE_KEY):
self.web3 = connect_web3(url)
if not self.web3.isConnected():
raise Exception("node connection failed")
self.eth = Eth(self.web3)
self.address = Web3.toChecksumAddress(address)
self.privatekey = privatekey
self.gasPrice = "0x8250de00"
self.gas = "0x6fffffff"
def setup_class(self):
self.ppos_link = Ppos(
self.rpc_list[0], self.address)
self.w3_list = [connect_web3(url) for url in self.rpc_list]
"""用新的钱包地址和未质押过的节点id封装对象"""
self.ppos_noconsensus_1 = Ppos(self.rpc_list[0], self.account_list[0], privatekey= self.privatekey_list[0])
self.ppos_noconsensus_2 = Ppos(self.rpc_list[0], self.account_list[1], privatekey=self.privatekey_list[1])
self.ppos_noconsensus_3 = Ppos(self.rpc_list[0], self.account_list[2], privatekey=self.privatekey_list[2])
for to_account in self.account_list:
self.transaction(self.w3_list[0],self.address,to_account)
def test_start_all_node():
"""
用例id：50
用于测试启动所有共识节点后，检查出块情况
"""
log.info("部署{}节点".format(n))
auto.start_all_node(node_yml)
log.info("跟所有节点建立连接")
w3_list = [connect_web3(url) for url in url_list]
check_block_sync(w3_list)
def transfer_parameters(self, to_address, from_address):
self.w3_list = [connect_web3(url) for url in self.rpc_list]
self.send_data = {
"to": to_address,
"from": from_address,
"gas": '9000',
"gasPrice": '1000000000',
"value": self.w3_list[0].toWei(100000, 'ether'),
}
return self.send_data
def check_block_node(urls_list, n):
time.sleep(10)
w3_list = [connect_web3(url) for url in urls_list]
log.info("查询所有节点块高")
start = max([w3.eth.blockNumber for w3 in w3_list])
log.info("开始块高：{}".format(start))
log.info("sleep {}s".format(n * 10))
time.sleep(n * 10)
end = max([w3.eth.blockNumber for w3 in w3_list])
log.info("结束块高:{}".format(end))
assert end - start > 0, "没有出块了"
def test_init_same_genesis_join_chain(self):
'''
测试相同的genesis.json节点加入addPeer
'''
self.auto.start_of_list(self.nocollusion_list[0:1],
genesis_file=self.genesis_file)
time.sleep(2)
w3 = connect_web3(self.one_collusion_url)
w3.admin.addPeer(self.enode_list[0])
time.sleep(5)
assert w3.net.peerCount > 0, "加入链失败"
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 check_blocknumber(url_list, number, n):
log.info(n)
time.sleep(20)
w3_list = [connect_web3(url) for url in url_list]
start_blocknumbers = [w3.eth.blockNumber for w3 in w3_list]
log.info("开始块高：{}".format(start_blocknumbers))
start_max_value = max(start_blocknumbers)
log.info("sleep {}s".format(n * 10))
time.sleep(int(n * 10))
end_blocknumbers = [w3.eth.blockNumber for w3 in w3_list]
log.info("结束块高:{}".format(end_blocknumbers))
end_max_value = max(end_blocknumbers)
assert end_max_value - start_max_value >= number, "出块数少于{}".format(number)
def test_start_mini_node():
"""
用例id:51
测试启动共识节点达到最低共识节点数量时，开始出块
"""
num = int(2*f+1)
log.info("部署{}个节点".format(num))
auto.start_of_list(
collusion_list[0:num], genesis_file=genesis_file, static_node_file=static_node_file)
time.sleep(30)
log.info("跟所有节点建立连接")
w3_list = [connect_web3(url) for url in url_list[0:num]]
check_block_sync(w3_list)
def test_to_account_is_empty():
'''
to账号为空，转账失败
:return:
'''
collusion_w3 = connect_web3(collusion_list[0]["url"])
from_account = collusion_w3.toChecksumAddress(conf.ADDRESS)
collusion_w3.personal.unlockAccount(from_account, conf.PASSWORD, 666666)
status = 0
try:
transaction(collusion_w3, from_account)
except:
status = 1
assert status == 1, 'to账号为空预期转账不成功，实际结果出现异常'
def test_consensus_unlock_sendtransaction():
'''
共识节点unlock转账
'''
collusion_w3 = connect_web3(collusion_list[0]["url"])
nocollusion_w3 = connect_web3(nocollusion_list[0]["url"])
eth = Eth(collusion_w3)
from_account = collusion_w3.toChecksumAddress(conf.ADDRESS)
# 非共识节点新建一个钱包
new_account = nocollusion_w3.personal.newAccount(conf.PASSWORD)
time.sleep(2)
to_account = collusion_w3.toChecksumAddress(new_account)
before_value = eth.getBalance(to_account)
collusion_w3.personal.unlockAccount(from_account, conf.PASSWORD, 666666)
# 共识节点转账给非共识节点新建的钱包
tx_hash = transaction(collusion_w3, from_account, to_account)
transaction_hash = HexBytes(tx_hash).hex()
try:
result = eth.waitForTransactionReceipt(transaction_hash)
except:
assert False, '等待超时，交易哈希：{}'.format(transaction_hash)
after_value = eth.getBalance(to_account)
assert result is not None, '交易在pending，未上链'
assert after_value - before_value == 1000000000000000000000, '交易失败，转账金额未到账'
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_init_diff_genesis_join_chain(self):
'''
使用不同genesis.json，addPeer
'''
self.auto.start_of_list(self.nocollusion_list[0:1],
genesis_path=conf.GENESIS_TMP_OTHER)
time.sleep(2)
net_num_1 = self.w3_list[0].net.peerCount
w3 = connect_web3(self.one_collusion_url)
w3.admin.addPeer(self.enode_list[0])
time.sleep(5)
net_num_2 = self.w3_list[0].net.peerCount
assert net_num_2 == net_num_1, "节点数有增加"
peers = w3.net.peerCount
log.info("加入其他链后，连接节点数{}".format(peers))
assert peers is 0, "peers节点数不为空"
def __init__(self,
url,
address,
pwd,
abi=r"./data/dpos/candidateConstract.json",
vote_abi=r'./data/dpos/ticketContract.json',
privatekey=conf.PRIVATE_KEY):
self.web3 = connect_web3(url)
if not self.web3.isConnected():
raise Exception("节点连接失败")
self.eth = Eth(self.web3)
self.address = address
self.abi = abi
self.vote_abi = vote_abi
self.value = 100
self.privatekey = privatekey
def test_start_2f():
"""
用例id：56
启动2f个节点
"""
num = int(2*f)
log.info("部署{}个节点".format(num))
auto.start_of_list(
collusion_list[0:num], genesis_file=genesis_file, static_node_file=static_node_file)
time.sleep(4)
log.info("跟所有节点建立连接")
w3_list = [connect_web3(url) for url in url_list[0:num]]
log.info("查询所有节点块高")
block_list = [w3.eth.blockNumber for w3 in w3_list]
log.info("所有节点块高：{}".format(block_list))
max_value = max(block_list)
assert max_value == 0, "出块了"
def check_deploy_status(self, node_list):
"""
校验部署结果
:param node_list:
:return:
"""
fail_list = []
time.sleep(10)
for node in node_list:
w3 = connect_web3(node["url"])
if not w3.isConnected():
fail_info = str(node["host"]) + ":" + str(node["port"])
fail_list.append(fail_info)
if len(fail_list) > 0:
raise Exception("部署失败：启动失败的节点如下{}".format(fail_list))
else:
log.info("所有节点启动成功")
def test_illegal_account_transaction():
'''
to账号为非法
:return:
'''
collusion_w3 = connect_web3(collusion_list[0]["url"])
from_account = collusion_w3.toChecksumAddress(conf.ADDRESS)
status = 0
try:
to_account = collusion_w3.toChecksumAddress(
'efcdefcvcswavsddrvfvgewvge0544646464')
collusion_w3.personal.unlockAccount(from_account, conf.PASSWORD,
666666)
transaction(collusion_w3, from_account, to_account)
except:
status = 1
assert status == 1, 'to账号为非法预期转账不成功，实际结果出现异常'
def __init__(self,
url,
address,
pwd,
abi=r"./data/dpos/candidateConstract.json",
vote_abi=r'./data/dpos/ticketContract.json'):
self.web3 = connect_web3(url)
if not self.web3.isConnected():
raise Exception("节点连接失败")
print("连接成功")
self.eth = Eth(self.web3)
self.address = address
if not self.web3.personal.unlockAccount(self.address, pwd, 22222):
raise Exception("账号解锁失败")
print("解锁账号成功")
self.abi = abi
self.vote_abi = vote_abi
self.value = 100
def test_no_init_no_join_chain(self):
'''
不初始化启动节点
'''
self.auto.start_of_list(self.nocollusion_list[0:1],
is_need_init=False,
clean=True)
time.sleep(1)
w3 = connect_web3(self.one_collusion_url)
start_block = w3.eth.blockNumber
time.sleep(10)
end_block = w3.eth.blockNumber
assert start_block == end_block, "区块高度增长了，开始块高{}-结束块高{}".format(
start_block, end_block)
w3.admin.addPeer(self.enode_list[0])
time.sleep(5)
net_num = w3.net.peerCount
assert net_num == 0, "连接节点数有增加"
