def test_max_block_user_tx(self):
max_block_user_tx = utils.get_system_parameter(conf["1"]["dbHost"],
conf["1"]["dbName"],
conf["1"]["login"],
conf["1"]["pass"],
"max_block_user_tx")
self.update_sys_param("max_block_user_tx", "1")
time.sleep(30)
i = 1
while i < 10:
name = "cont" + utils.generate_random_name()
code = "contract " + name + contract["limits"]["code"]
data = {
"Wallet": "",
"Value": code,
"ApplicationId": 1,
"Conditions": "true"
}
utils.call_contract(conf["2"]["url"], conf["1"]['private_key'],
"NewContract", data, token)
i = i + 1
time.sleep(5)
maxBlock = funcs.get_max_block_id(conf["2"]["url"], token)
print("maxBlock = ", maxBlock)
isOneOrTwo = utils.isCountTxInBlock(conf["2"]["dbHost"],
conf["2"]["dbName"],
conf["2"]["login"],
conf["2"]["pass"], maxBlock, 1)
self.update_sys_param("max_block_user_tx ", str(max_block_user_tx))
time.sleep(30)
self.assertTrue(isOneOrTwo,
"One of block contains more than 2 transaction")
def test_get_content_from_another_ecosystem(self):
# create new ecosystem
ecosysName = "Ecosys_" + utils.generate_random_name()
data = {"Name": ecosysName}
res = self.call("NewEcosystem", data)
self.assertGreater(int(res), 0,
"BlockId is not generated: " + str(res))
ecosysNum = funcs.call_get_api(url + "/ecosystems/", "",
token)["number"]
# login founder in new ecosystem
data2 = utils.login(url, prKey, 0, ecosysNum)
token2 = data2["jwtToken"]
# create page in new ecosystem
pageName = "Page_" + utils.generate_random_name()
pageText = "Page in " + str(ecosysNum) + " ecosystem"
pageValue = "Span(" + pageText + ")"
data = {
"Name": pageName,
"Value": pageValue,
"ApplicationId": 1,
"Conditions": "true",
"Menu": "default_menu"
}
resp = utils.call_contract(url, prKey, "@1NewPage", data, token2)
status = utils.txstatus(url, pause, resp["hash"], token2)
self.assertGreater(int(status["blockid"]), 0,
"BlockId is not generated: " + str(status))
# create menu in new ecosystem
menuName = "Menu_" + utils.generate_random_name()
menuTitle = "Test menu"
data = {
"Name": menuName,
"Value": "MenuItem(Title:\"" + menuTitle + "\")",
"ApplicationId": 1,
"Conditions": "true"
}
resp = utils.call_contract(url, prKey, "@1NewMenu", data, token2)
status = utils.txstatus(url, pause, resp["hash"], token2)
self.assertGreater(int(status["blockid"]), 0,
"BlockId is not generated: " + str(status))
# test
data = ""
asserts = ["tree"]
resPage = self.check_post_api(
"/content/page/@" + str(ecosysNum) + pageName, data, asserts)
resMenu = self.check_post_api(
"/content/menu/@" + str(ecosysNum) + menuName, data, asserts)
mustBe = dict(pageText=pageText, menu=menuTitle)
expectedValue = dict(
pageText=resPage["tree"][0]["children"][0]["text"],
menu=resMenu["tree"][0]["attr"]["title"])
self.assertEqual(mustBe, expectedValue, "Dictionaries are different!")
def rolesInsatll(url, prKey, token):
data = {}
print("RolesInstall started")
call = utils.call_contract(url, prKey, "RolesInstall", data, token)
if not isInBlock(call, url, token):
print("RolesInstall is failed")
exit(1)
def test_money_transfer(self):
balanceNodeOwnerB = utils.get_balance_from_db(conf["1"]["dbHost"],
conf["1"]["dbName"],
conf["1"]["login"],
conf["1"]["pass"],
conf["2"]["keyID"])
commisionWallet = utils.get_commission_wallet(conf["1"]["dbHost"],
conf["1"]["dbName"],
conf["1"]["login"],
conf["1"]["pass"], 1)
balanceCommisionB = utils.get_balance_from_db(conf["1"]["dbHost"],
conf["1"]["dbName"],
conf["1"]["login"],
conf["1"]["pass"],
commisionWallet)
tokenRunner, uid = utils.get_uid(conf["2"]["url"])
signature = sign(keys["key2"], uid)
pubRunner = get_public_key(keys["key2"])
balanceRunnerB = utils.get_balance_from_db_by_pub(
conf["1"]["dbHost"], conf["1"]["dbName"], conf["1"]["login"],
conf["1"]["pass"], pubRunner)
dataRunner = utils.login(conf["2"]["url"], keys["key2"], 0)
tokenRunner = dataRunner["jwtToken"]
data = {"Recipient": "0005-2070-2000-0006-0200", "Amount": "1000"}
res = utils.call_contract(conf["2"]["url"], keys["key2"],
"MoneyTransfer", data, tokenRunner)
hash = res["hash"]
result = utils.txstatus(conf["2"]["url"],
conf["2"]["time_wait_tx_in_block"], hash,
tokenRunner)
balanceRunnerMust = balanceRunnerB - 1000
balanceRunnerB = utils.get_balance_from_db_by_pub(
conf["1"]["dbHost"], conf["1"]["dbName"], conf["1"]["login"],
conf["1"]["pass"], pubRunner)
def is_node_owner_true(self):
data = {}
resp = utils.call_contract(url, prKey, "NodeOwnerCondition", data,
token)
status = utils.txstatus(url, pause, resp["hash"], token)
self.assertGreater(int(status["blockid"]), 0,
"BlockId is not generated: " + str(status))
def new_citizen():
resp = requests.get(config.ENDPOINT + "ecosystemslist")
form = forms.NewCitizenForm(request.form)
form.financial_institution.choices = config.ECOSYSTEM_CHOICES
if request.method == 'POST' and form.validate():
data = {}
data["ecosystem_id"] = int(request.form["financial_institution"])
data["wallet_address"] = request.form["wallet_address"]
data["firstname"] = request.form["first_name"]
data["lastname"] = request.form["last_name"]
data["citizenship"] = request.form["citizenship"]
utils.call_contract(config.ENDPOINT, config.PRKEY, "WaletRequest",
data)
form = forms.NewCitizenForm()
form.financial_institution.choices = config.ECOSYSTEM_CHOICES
return render_template('new_citizen.html', form=form)
def test_contract_callContract(self):
contract = self.contracts["myContract"]
code = "contract MyContract" + contract["code"]
data = {"Value": code, "ApplicationId": 1, "Conditions": "true"}
res = utils.call_contract(url, prKey, "NewContract", data, token)
time.sleep(10)
contract = self.contracts["callContract"]
self.check_contract(contract["code"], contract["asert"])
def call(self, name, data):
url = self.config["2"]["url"]
prKey = self.config["1"]['private_key']
token = self.data["jwtToken"]
result = utils.call_contract(url, prKey, name, data, token)
status = utils.txstatus(url, self.config["1"]["time_wait_tx_in_block"],
result['hash'], token)
return status
def editAppParam(name, val, url, prKey, token):
id = funcs.get_object_id(url, name, "app_params", token)
print("id", id)
data = {"Id": id, "Name": name, "Value": val, "Conditions": "true"}
call = utils.call_contract(url, prKey, "EditAppParam", data, token)
if not isInBlock(call, url, token):
print("EditAppParam " + name + " is failed")
exit(1)
def voitingInstall(url, prKey, token):
data = {}
print("voitingInstall started")
call = utils.call_contract(url, prKey, "VotingTemplatesInstall", data,
token)
if not isInBlock(call, url, token):
print("VoitingInstall is failed")
exit(1)
def create_contract(self, code):
data = {
"Wallet": "",
"ApplicationId": 1,
"Value": code,
"Conditions": "ContractConditions(\"MainCondition\")"
}
result = utils.call_contract(url, prKey, "NewContract", data, token)
self.assertTxInBlock(result, token)
def voiting(id, url, prKey, token):
data = {"votingID": id}
call = utils.call_contract(url, prKey, "VotingDecisionAccept", data, token)
if not isInBlock(call, url, token):
print("VotingDecisionAccept " + id + " is failed")
exit(1)
return False
return True
def setAplaConsensus(id, url, prKey, token):
data = {"member_id": id, "rid": 3}
call = utils.call_contract(url, prKey, "RolesAssign", data, token)
print(
"--------------------------------------------------------------------------"
)
print("setAplaconsensus block: ", call)
if not isInBlock(call, url, token):
print("RolesAssign " + id + " is failed")
exit(1)
def test_contract_langRes(self):
data = {
"ApplicationId": 1,
"Name": "test",
"Trans": "{\"en\": \"test_en\", \"de\" : \"test_de\"}"
}
result = utils.call_contract(url, prKey, "NewLang", data, token)
tx = utils.txstatus(url, self.config["1"]["time_wait_tx_in_block"],
result['hash'], token)
contract = self.contracts["langRes"]
self.check_contract(contract["code"], contract["asert"])
def create_contract(self, url, prKey):
code, name = utils.generate_name_and_code("")
data = {
'Wallet': '',
'Value': code,
"ApplicationId": 1,
'Conditions': "ContractConditions(`MainCondition`)"
}
resp = utils.call_contract(url, prKey, "NewContract", data,
self.data1["jwtToken"])
return name
def test_sys_var_role_id_readonly(self):
sysVarName = "$role_id"
contracName = utils.generate_random_name()
value = "contract con_" + contracName + " { data{ } conditions{ } action{ " + sysVarName + " = 5 } }"
data = {"Value": value, "ApplicationId": 1, "Conditions": "true"}
result = utils.call_contract(url, prKey, "NewContract", data, token)
tx = utils.txstatus(url, self.config["1"]["time_wait_tx_in_block"],
result['hash'], token)
expResult = "system variable " + sysVarName + " cannot be changed"
msg = "system variable " + sysVarName + " was been changed!"
self.assertEqual(tx["errmsg"]["error"], expResult, msg)
def check_contract_with_data(self, sourse, data, checkPoint):
code, name = self.generate_name_and_code(sourse)
self.create_contract(code)
url = self.config["2"]["url"]
prKey = self.config["1"]['private_key']
token = self.data["jwtToken"]
sleep = self.config["1"]["time_wait_tx_in_block"]
res = utils.call_contract(url, prKey, name, data, token)
hash = res["hash"]
result = utils.txstatus(url, sleep, hash, token)
self.assertIn(checkPoint, result["result"], "error")
def is_node_owner_false(self):
keys = config.getKeys()
prKey2 = keys["key1"]
data2 = utils.login(url, prKey2, 0)
token2 = data2["jwtToken"]
data = {}
resp = utils.call_contract(url, prKey2, "NodeOwnerCondition", data,
token2)
status = utils.txstatus(url, pause, resp["hash"], token2)
self.assertEqual(status["errmsg"]["error"],
"Sorry, you do not have access to this action.",
"Incorrect message: " + str(status))
def createVoiting(tcpAdress, apiAddress, keyId, pubKey, url, prKey, token):
data = {
"TcpAddress": tcpAdress,
"ApiAddress": apiAddress,
"KeyId": keyId,
"PubKey": pubKey,
"Duration": 1
}
print(str(data))
call = utils.call_contract(url, prKey, "VotingNodeAdd", data, token)
if not isInBlock(call, url, token):
print("VotingNodeAdd is failed")
exit(1)
def deactivateContract(self):
dataCreater = utils.login(conf["1"]["url"], conf["1"]["private_key"],
0)
tokenCreater = dataCreater["jwtToken"]
id = funcs.get_contract_id(conf["1"]["url"], "CostContract",
tokenCreater)
data = {"Id": id}
result = utils.call_contract(conf["1"]["url"],
conf["1"]["private_key"],
"DeactivateContract", data, tokenCreater)
status = utils.txstatus(conf["1"]["url"],
conf["1"]["time_wait_tx_in_block"],
result['hash'], tokenCreater)
def test_contract_dbInsert(self):
columns = """[{"name":"name","type":"varchar",
"index": "1", "conditions":"true"},
{"name":"test","type":"varchar",
"index": "0", "conditions":"true"}]"""
permission = """{"insert": "true",
"update" : "true","new_column": "true"}"""
data = {
"Name": "test",
"ApplicationId": 1,
"Columns": columns,
"Permissions": permission
}
result = utils.call_contract(url, prKey, "NewTable", data, token)
tx = utils.txstatus(url, self.config["1"]["time_wait_tx_in_block"],
result['hash'], token)
contract = self.contracts["dbInsert"]
self.check_contract(contract["code"], contract["asert"])
def test_z1_dbSelectMetricsMin(self):
# func generate contract which return block_id and increment count blocks
def waitBlockId(old_block_id, limit):
while True:
if old_block_id == limit:
break
contracName = utils.generate_random_name()
value = "contract con_" + contracName + " {\n data{} \n conditions{} \n action { \n $result = $block \n } \n }"
data = {
"Value": value,
"ApplicationId": 1,
"Conditions": "true"
}
result = utils.call_contract(url, prKey, "NewContract", data,
token)
tx = utils.txstatus(url,
self.config["1"]["time_wait_tx_in_block"],
result['hash'], token)
current_block_id = int(tx["blockid"])
self.assertGreater(current_block_id, 0,
"BlockId is not generated: " + str(tx))
old_block_id = current_block_id
# generate contract which return count blocks in blockchain
contracName = utils.generate_random_name()
value = "contract con_" + contracName + " {\n data{} \n conditions{} \n action { \n $result = $block \n } \n }"
data = {"Value": value, "ApplicationId": 1, "Conditions": "true"}
result = utils.call_contract(url, prKey, "NewContract", data, token)
tx = utils.txstatus(url, self.config["1"]["time_wait_tx_in_block"],
result['hash'], token)
current_block_id = int(tx["blockid"])
self.assertGreater(current_block_id, 0,
"BlockId is not generated: " + str(tx))
# wait until generated 100 blocks
if current_block_id < 100:
waitBlockId(current_block_id, 100)
# wait until generated multiples of 100 blocks
if (current_block_id % 100 >= 90):
count = current_block_id + (100 - (current_block_id % 100))
waitBlockId(current_block_id, count)
# test
ecosystem_tx = self.getMetrics(1, "ecosystem_tx")
contract = self.contracts["dbSelectMetricsMin"]
self.check_contract(contract["code"], str(ecosystem_tx))
def createContracts(self):
global dataCreater
dataCreater = utils.login(conf["1"]["url"], conf["1"]["private_key"],
0)
tokenCreater = dataCreater["jwtToken"]
contract = config.readFixtures("contracts")
code = "contract CostContract" + contract["for_cost"]["code"]
data = {
"Wallet": "",
"Value": code,
"ApplicationId": 1,
"Conditions": "true"
}
result = utils.call_contract(conf["1"]["url"],
conf["1"]["private_key"], "NewContract",
data, tokenCreater)
status = utils.txstatus(conf["1"]["url"],
conf["1"]["time_wait_tx_in_block"],
result['hash'], tokenCreater)
print(status)
def waitBlockId(old_block_id, limit):
while True:
if old_block_id == limit:
break
contracName = utils.generate_random_name()
value = "contract con_" + contracName + " {\n data{} \n conditions{} \n action { \n $result = $block \n } \n }"
data = {
"Value": value,
"ApplicationId": 1,
"Conditions": "true"
}
result = utils.call_contract(url, prKey, "NewContract", data,
token)
tx = utils.txstatus(url,
self.config["1"]["time_wait_tx_in_block"],
result['hash'], token)
current_block_id = int(tx["blockid"])
self.assertGreater(current_block_id, 0,
"BlockId is not generated: " + str(tx))
old_block_id = current_block_id
def call(self, name, data):
resp = utils.call_contract(url, prKey, name, data, token)
res = utils.txstatus(url, waitTx, resp['hash'], token)
return res
def call(self, name, data):
resp = utils.call_contract(conf["2"]["url"], conf["1"]['private_key'],
name, data, token)
res = self.assertTxInBlock(resp, token)
return res
def test_deactive_contract_with_err(self):
if funcs.is_contract_activated(conf["2"]["url"], "CostContract",
self.token) == True:
self.deactivateContract()
walletId = funcs.get_activated_wallet(conf["2"]["url"], "CostContract",
self.token)
balanceContractOwnerB = utils.get_balance_from_db(
conf["1"]["dbHost"], conf["1"]["dbName"], conf["1"]["login"],
conf["1"]["pass"], walletId)
balanceNodeOwnerB = utils.get_balance_from_db(conf["1"]["dbHost"],
conf["1"]["dbName"],
conf["1"]["login"],
conf["1"]["pass"],
conf["2"]["keyID"])
commisionWallet = utils.get_commission_wallet(conf["1"]["dbHost"],
conf["1"]["dbName"],
conf["1"]["login"],
conf["1"]["pass"], 1)
balanceCommisionB = utils.get_balance_from_db(conf["1"]["dbHost"],
conf["1"]["dbName"],
conf["1"]["login"],
conf["1"]["pass"],
commisionWallet)
commission = utils.get_system_parameter(conf["1"]["dbHost"],
conf["1"]["dbName"],
conf["1"]["login"],
conf["1"]["pass"],
"commission_size")
tokenRunner, uid = utils.get_uid(conf["2"]["url"])
signature = sign(keys["key2"], uid)
pubRunner = get_public_key(keys["key2"])
balanceRunnerB = utils.get_balance_from_db_by_pub(
conf["1"]["dbHost"], conf["1"]["dbName"], conf["1"]["login"],
conf["1"]["pass"], pubRunner)
dataRunner = utils.login(conf["2"]["url"], keys["key2"], 0)
tokenRunner = dataRunner["jwtToken"]
res = utils.call_contract(conf["2"]["url"], keys["key2"],
"CostContract", {"State": 0}, tokenRunner)
time.sleep(10)
hash = res["hash"]
result = utils.txstatus(conf["2"]["url"],
conf["2"]["time_wait_tx_in_block"], hash,
tokenRunner)
balanceContractOwnerA = utils.get_balance_from_db(
conf["1"]["dbHost"], conf["1"]["dbName"], conf["1"]["login"],
conf["1"]["pass"], walletId)
balanceNodeOwnerA = utils.get_balance_from_db(conf["1"]["dbHost"],
conf["1"]["dbName"],
conf["1"]["login"],
conf["1"]["pass"],
conf["2"]["keyID"])
balanceCommisionA = utils.get_balance_from_db(conf["1"]["dbHost"],
conf["1"]["dbName"],
conf["1"]["login"],
conf["1"]["pass"],
commisionWallet)
balanceRunnerA = utils.get_balance_from_db_by_pub(
conf["1"]["dbHost"], conf["1"]["dbName"], conf["1"]["login"],
conf["1"]["pass"], pubRunner)
dictValid = dict(balanceContractOwner=balanceContractOwnerA,
balanceNodeOwner=balanceNodeOwnerA,
balanceCommision=balanceCommisionA,
balanceRunner=balanceRunnerA)
dictExpect = dict(balanceContractOwner=balanceContractOwnerB,
balanceNodeOwner=balanceNodeOwnerB,
balanceCommision=balanceCommisionB,
balanceRunner=balanceRunnerB)
msg = "balanceContractOwnerA:" + str(balanceContractOwnerA) + "\n" +\
"balanceContractOwnerE:" + str(balanceContractOwnerB) + "\n" +\
"balanceNodeOwnerA:" + str(balanceNodeOwnerA) + "\n" +\
"balanceNodeOwnerE:" + str(balanceNodeOwnerB) + "\n" +\
"balanceCommisionA:" + str(balanceCommisionA) + "\n" +\
"balanceCommisionE:" + str(balanceCommisionB) + "\n" +\
"balanceRunnerA:" + str(balanceRunnerA) + "\n" +\
"balanceRunnerE:" + str(balanceRunnerB) + "\n"
self.assertDictEqual(dictValid, dictExpect, msg)
def test_deactive_contract(self):
if funcs.is_contract_activated(conf["2"]["url"], "CostContract",
self.token) == True:
self.deactivateContract()
walletId = funcs.get_activated_wallet(conf["2"]["url"], "CostContract",
self.token)
sumsBefore = utils.getUserTokenAmounts(conf["1"]["dbHost"],
conf["1"]["dbName"],
conf["1"]["login"],
conf["1"]["pass"])
summBefore = sum(summ[0] for summ in sumsBefore)
bNodeBalance = self.getNodeBalances()
tokenRunner, uid = utils.get_uid(conf["2"]["url"])
signature = sign(keys["key2"], uid)
pubRunner = get_public_key(keys["key2"])
balanceRunnerB = utils.get_balance_from_db_by_pub(
conf["1"]["dbHost"], conf["1"]["dbName"], conf["1"]["login"],
conf["1"]["pass"], pubRunner)
dataRunner = utils.login(conf["2"]["url"], keys["key2"], 0)
tokenRunner = dataRunner["jwtToken"]
res = utils.call_contract(conf["2"]["url"], keys["key2"],
"CostContract", {"State": 1}, tokenRunner)
result = utils.txstatus(conf["2"]["url"],
conf["2"]["time_wait_tx_in_block"],
res["hash"], tokenRunner)
time.sleep(10)
node = utils.get_block_gen_node(conf["1"]["dbHost"],
conf["1"]["dbName"],
conf["1"]["login"], conf["1"]["pass"],
result["blockid"])
sumsAfter = utils.getUserTokenAmounts(conf["1"]["dbHost"],
conf["1"]["dbName"],
conf["1"]["login"],
conf["1"]["pass"])
summAfter = sum(summ[0] for summ in sumsAfter)
aNodeBalance = self.getNodeBalances()
nodeCommission = 141620000000000000
platformaCommission = 4380000000000000
commission = nodeCommission + platformaCommission
balanceRunnerA = utils.get_balance_from_db_by_pub(
conf["1"]["dbHost"], conf["1"]["dbName"], conf["1"]["login"],
conf["1"]["pass"], pubRunner)
balanceContractOwnerA = utils.get_balance_from_db(
conf["1"]["dbHost"], conf["1"]["dbName"], conf["1"]["login"],
conf["1"]["pass"], walletId)
inHistory = self.isCommissionsInHistory(nodeCommission,
dataRunner["key_id"],
platformaCommission, node)
if node == 0:
dictValid = dict(balanceRunner=balanceRunnerA,
platformBalance=aNodeBalance[0],
summ=summBefore,
history=inHistory)
dictExpect = dict(balanceRunner=balanceRunnerB - commission,
platformBalance=bNodeBalance[0] + commission,
summ=summAfter,
history=True)
else:
dictValid = dict(balanceRunner=balanceRunnerA,
platformBalance=aNodeBalance[0],
nodeBalance=aNodeBalance[node],
summ=summBefore,
history=inHistory)
dictExpect = dict(balanceRunner=balanceRunnerB - commission,
platformBalance=bNodeBalance[0] +
platformaCommission,
nodeBalance=bNodeBalance[node] + nodeCommission,
summ=summAfter,
history=True)
self.assertDictEqual(dictValid, dictExpect,
"Error in comissions run deactivated contract")
def new_menu(self, url, prKey):
name = "Menu_" + utils.generate_random_name()
data = {"Name": name, "Value": "Item1", "Conditions": "true"}
res = utils.call_contract(url, prKey, "NewMenu", data,
self.data1["jwtToken"])
return funcs.get_count(url, "menu", self.data1["jwtToken"])
def edit_menu(self, url, prKey, id):
dataEdit = {"Id": id, "Value": "tryam", "Conditions": "true"}
res = utils.call_contract(url, prKey, "EditMenu", dataEdit,
self.data1["jwtToken"])
