Mirroristas/planetmint
2
0
Fork 0
mirror of https://github.com/planetmint/planetmint.git synced 2025-11-24 06:25:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

fixed some test cases

Browse Source 
Signed-off-by: Lorenz Herzberger <lorenzherzberger@gmail.com>
This commit is contained in:
Lorenz Herzberger 2022-10-24 11:15:00 +02:00
parent f03d9ce925
commit 8a254f4640
No known key found for this signature in database
GPG Key ID: FA5EE906EB55316A
18 changed files with 91 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
planetmint/backend/tarantool/convert.py
View File

@ -13,11 +13,11 @@ register_query = module_dispatch_registrar(convert)
@register_query(TarantoolDBConnection)
def prepare_asset(connection, transaction_type, transaction_id, filter_operation, asset):
def prepare_asset(connection, transaction_type, transaction_id, filter_operation, assets):
asset_id = transaction_id
if transaction_type not in filter_operation:
asset_id = asset["id"]
return tuple([asset, transaction_id, asset_id])
asset_id = assets[0]["id"]
return tuple([assets, transaction_id, asset_id])
@register_query(TarantoolDBConnection)

4
planetmint/backend/tarantool/query.py
View File

@ -41,7 +41,7 @@ def _group_transaction_by_ids(connection, txids: list):
"inputs": _txinputs,
"outputs": _txoutputs,
"keys": _txkeys,
"asset": _txassets,
"assets": _txassets,
"metadata": _txmeta,
"script": _txscript,
}
@ -238,7 +238,7 @@ def text_search(conn, search, table="assets", limit=0):
if len(res[0]): # NEEDS BEAUTIFICATION
if table == "assets":
for result in res[0]:
to_return.append({"data": json.loads(result[0])["data"], "id": result[1]})
to_return.append({"data": json.loads(result[0])[0]["data"], "id": result[1]})
else:
for result in res[0]:
to_return.append({"metadata": json.loads(result[1]), "id": result[0]})

8
planetmint/backend/tarantool/transaction/tools.py
View File

@ -65,11 +65,11 @@ class TransactionDecompose:
self._tuple_transaction["metadata"] = (self._transaction["id"], json.dumps(metadata))
def __asset_check(self):
_asset = self._transaction.get("asset")
_asset = self._transaction.get("assets")
if _asset is None:
return
asset_id = _asset["id"] if _asset.get("id") is not None else self._transaction["id"]
self._tuple_transaction["asset"] = (json.dumps(_asset), self._transaction["id"], asset_id)
self._tuple_transaction["assets"] = (json.dumps(_asset), self._transaction["id"], asset_id)
def __prepare_inputs(self):
_inputs = []
@ -167,7 +167,7 @@ class TransactionCompose:
return self.db_results["transaction"][0]
def _get_asset(self):
_asset = iter(self.db_results["asset"])
_asset = iter(self.db_results["assets"])
_res_asset = next(iter(next(_asset, iter([]))), None)
return json.loads(_res_asset)
@ -215,7 +215,7 @@ class TransactionCompose:
def convert_to_dict(self):
transaction = {k: None for k in list(self._map.keys())}
transaction["id"] = self._get_transaction_id()
transaction["asset"] = self._get_asset()
transaction["assets"] = self._get_asset()
transaction["metadata"] = self._get_metadata()
transaction["version"] = self._get_transaction_version()
transaction["operation"] = self._get_transaction_operation()

16
planetmint/commands/planetmint.py
View File

@ -153,11 +153,13 @@ def run_election_new_upsert_validator(args, planet):
:return: election_id or `False` in case of failure
"""
new_validator = {
"public_key": {"value": public_key_from_base64(args.public_key), "type": "ed25519-base16"},
"power": args.power,
"node_id": args.node_id,
}
new_validator = [{
"data": {
"public_key": {"value": public_key_from_base64(args.public_key), "type": "ed25519-base16"},
"power": args.power,
"node_id": args.node_id,
}
}]
return create_new_election(args.sk, planet, ValidatorElection, new_validator)
@ -173,7 +175,7 @@ def run_election_new_chain_migration(args, planet):
:return: election_id or `False` in case of failure
"""
return create_new_election(args.sk, planet, ChainMigrationElection, {})
return create_new_election(args.sk, planet, ChainMigrationElection, [{"data": {}}])
def run_election_approve(args, planet):
@ -199,7 +201,7 @@ def run_election_approve(args, planet):
inputs = [i for i in tx.to_inputs() if key.public_key in i.owners_before]
election_pub_key = election_id_to_public_key(tx.id)
approval = Vote.generate(inputs, [([election_pub_key], voting_power)], tx.id).sign([key.private_key])
approval = Vote.generate(inputs, [([election_pub_key], voting_power)], [tx.id]).sign([key.private_key])
planet.validate_transaction(approval)
resp = planet.write_transaction(approval, BROADCAST_TX_COMMIT)

23
planetmint/lib.py
View File

@ -251,13 +251,14 @@ class Planetmint(object):
transaction = backend.query.get_transaction(self.connection, transaction_id)
if transaction:
# TODO: get_assets is used with transaction_id this will not work with the asset change
assets = backend.query.get_assets(self.connection, [transaction_id])
# assets = backend.query.get_assets(self.connection, [transaction_id])
metadata = backend.query.get_metadata(self.connection, [transaction_id])
# NOTE: assets must not be replaced for transfer transactions
# TODO: check if this holds true for other tx types, some test cases connected to election and voting are still failing
# NOTE: assets should be appended for all txs that define new assets otherwise the ids are already stored in tx
if transaction["operation"] != "TRANSFER" and transaction["operation"] != "VOTE" and assets:
transaction["assets"] = list(assets)
# if transaction["operation"] != "TRANSFER" and transaction["operation"] != "VOTE" and assets:
# transaction["assets"] = list(assets)
# transaction["assets"] = [asset[0] for asset in assets]
if "metadata" not in transaction:
metadata = metadata[0] if metadata else None
@ -318,8 +319,8 @@ class Planetmint(object):
if len(transactions) + len(current_spent_transactions) > 1:
raise DoubleSpend('tx "{}" spends inputs twice'.format(txid))
elif transactions:
transaction = backend.query.get_transactions(self.connection, [transactions[0]["id"]])
transaction = Transaction.from_dict(transaction[0], False)
transaction = backend.query.get_transaction(self.connection, transactions[0]["id"])
transaction = Transaction.from_dict(transaction, False)
elif current_spent_transactions:
transaction = current_spent_transactions[0]
@ -433,7 +434,7 @@ class Planetmint(object):
# validate asset id
asset_id = tx.get_asset_id(input_txs)
if asset_id != tx.asset["id"]:
if asset_id != tx.assets[0]["id"]:
raise AssetIdMismatch(("The asset id of the input does not" " match the asset id of the" " transaction"))
if not tx.inputs_valid(input_conditions):
@ -679,7 +680,7 @@ class Planetmint(object):
current_validators = self.get_validators_dict()
# NOTE: change more than 1/3 of the current power is not allowed
if transaction.asset["data"]["power"] >= (1 / 3) * sum(current_validators.values()):
if transaction.assets[0]["data"]["power"] >= (1 / 3) * sum(current_validators.values()):
raise InvalidPowerChange("`power` change must be less than 1/3 of total power")
def get_election_status(self, transaction):
@ -735,7 +736,7 @@ class Planetmint(object):
return recipients
def show_election_status(self, transaction):
data = transaction.asset["data"]
data = transaction.assets[0]["data"]
if "public_key" in data.keys():
data["public_key"] = public_key_to_base64(data["public_key"]["value"])
response = ""
@ -817,7 +818,7 @@ class Planetmint(object):
if not isinstance(tx, Vote):
continue
election_id = tx.asset["id"]
election_id = tx.assets[0]["id"]
if election_id not in elections:
elections[election_id] = []
elections[election_id].append(tx)
@ -951,7 +952,7 @@ class Planetmint(object):
if election.operation == CHAIN_MIGRATION_ELECTION:
self.migrate_abci_chain()
if election.operation == VALIDATOR_ELECTION:
validator_updates = [election.asset["data"]]
validator_updates = [election.assets[0]["data"]]
curr_validator_set = self.get_validators(new_height)
updated_validator_set = new_validator_set(curr_validator_set, validator_updates)
@ -959,7 +960,7 @@ class Planetmint(object):
# TODO change to `new_height + 2` when upgrading to Tendermint 0.24.0.
self.store_validator_set(new_height + 1, updated_validator_set)
return encode_validator(election.asset["data"])
return encode_validator(election.assets[0]["data"])
Block = namedtuple("Block", ("app_hash", "height", "transactions"))

4
tests/commands/test_commands.py
View File

@ -515,7 +515,7 @@ def test_chain_migration_election_show_shows_inconclusive(b):
private_key = validators[0]["private_key"]
voter_keys = [v["private_key"] for v in validators]
election, votes = generate_election(b, ChainMigrationElection, public_key, private_key, {}, voter_keys)
election, votes = generate_election(b, ChainMigrationElection, public_key, private_key, [{"data": {}}], voter_keys)
assert not run_election_show(Namespace(election_id=election.id), b)
@ -544,7 +544,7 @@ def test_chain_migration_election_show_shows_concluded(b):
private_key = validators[0]["private_key"]
voter_keys = [v["private_key"] for v in validators]
election, votes = generate_election(b, ChainMigrationElection, public_key, private_key, {}, voter_keys)
election, votes = generate_election(b, ChainMigrationElection, public_key, private_key, [{"data": {}}], voter_keys)
assert not run_election_show(Namespace(election_id=election.id), b)

2
tests/conftest.py
View File

@ -709,7 +709,7 @@ def new_validator():
power = 1
node_id = "fake_node_id"
return {"public_key": {"value": public_key, "type": "ed25519-base16"}, "power": power, "node_id": node_id}
return [{"data": {"public_key": {"value": public_key, "type": "ed25519-base16"}, "power": power, "node_id": node_id}}]
@pytest.fixture

6
tests/db/test_planetmint_api.py
View File

@ -135,7 +135,7 @@ class TestTransactionValidation(object):
sk, pk = generate_key_pair()
tx = Create.generate([pk], [([user_pk], 1)])
tx.operation = "TRANSFER"
tx.asset = {"id": input_transaction.id}
tx.assets = [{"id": input_transaction.id}]
tx.inputs[0].fulfills = input_tx
with pytest.raises(InvalidSignature):
@ -476,10 +476,10 @@ def test_transaction_unicode(b, alice):
# http://www.fileformat.info/info/unicode/char/1f37a/index.htm
beer_python = {"data": multihash(marshal({"beer": "\N{BEER MUG}"}))}
beer_python = [{"data": multihash(marshal({"beer": "\N{BEER MUG}"}))}]
beer_json = {"data": multihash(marshal({"beer": "\N{BEER MUG}"}))}
tx = (Create.generate([alice.public_key], [([alice.public_key], 100)], asset=beer_python)).sign(
tx = (Create.generate([alice.public_key], [([alice.public_key], 100)], assets=beer_python)).sign(
[alice.private_key]
)

22
tests/elections/test_election.py
View File

@ -18,13 +18,13 @@ def test_process_block_concludes_all_elections(b):
private_key = validators[0]["private_key"]
voter_keys = [v["private_key"] for v in validators]
election, votes = generate_election(b, ChainMigrationElection, public_key, private_key, {}, voter_keys)
election, votes = generate_election(b, ChainMigrationElection, public_key, private_key, [{"data": {}}], voter_keys)
txs = [election]
total_votes = votes
election, votes = generate_election(
b, ValidatorElection, public_key, private_key, new_validator["election"], voter_keys
b, ValidatorElection, public_key, private_key, [{"data": new_validator["election"]}], voter_keys
)
txs += [election]
total_votes += votes
@ -64,7 +64,7 @@ def test_process_block_approves_only_one_validator_update(b):
voter_keys = [v["private_key"] for v in validators]
election, votes = generate_election(
b, ValidatorElection, public_key, private_key, new_validator["election"], voter_keys
b, ValidatorElection, public_key, private_key, [{"data": new_validator["election"]}], voter_keys
)
txs = [election]
total_votes = votes
@ -72,7 +72,7 @@ def test_process_block_approves_only_one_validator_update(b):
another_validator = generate_validators([1])[0]
election, votes = generate_election(
b, ValidatorElection, public_key, private_key, another_validator["election"], voter_keys
b, ValidatorElection, public_key, private_key, [{"data": another_validator["election"]}], voter_keys
)
txs += [election]
total_votes += votes
@ -104,7 +104,7 @@ def test_process_block_approves_after_pending_validator_update(b):
voter_keys = [v["private_key"] for v in validators]
election, votes = generate_election(
b, ValidatorElection, public_key, private_key, new_validator["election"], voter_keys
b, ValidatorElection, public_key, private_key, [{"data": new_validator["election"]}], voter_keys
)
txs = [election]
total_votes = votes
@ -112,12 +112,12 @@ def test_process_block_approves_after_pending_validator_update(b):
another_validator = generate_validators([1])[0]
election, votes = generate_election(
b, ValidatorElection, public_key, private_key, another_validator["election"], voter_keys
b, ValidatorElection, public_key, private_key, [{"data": another_validator["election"]}], voter_keys
)
txs += [election]
total_votes += votes
election, votes = generate_election(b, ChainMigrationElection, public_key, private_key, {}, voter_keys)
election, votes = generate_election(b, ChainMigrationElection, public_key, private_key, [{"data": {}}], voter_keys)
txs += [election]
total_votes += votes
@ -153,7 +153,7 @@ def test_process_block_does_not_approve_after_validator_update(b):
voter_keys = [v["private_key"] for v in validators]
election, votes = generate_election(
b, ValidatorElection, public_key, private_key, new_validator["election"], voter_keys
b, ValidatorElection, public_key, private_key, [{"data": new_validator["election"]}], voter_keys
)
txs = [election]
total_votes = votes
@ -163,7 +163,7 @@ def test_process_block_does_not_approve_after_validator_update(b):
b.store_bulk_transactions(txs)
second_election, second_votes = generate_election(
b, ChainMigrationElection, public_key, private_key, {}, voter_keys
b, ChainMigrationElection, public_key, private_key, [{"data": {}}], voter_keys
)
b.process_block(2, total_votes + [second_election])
@ -186,11 +186,11 @@ def test_process_block_applies_only_one_migration(b):
private_key = validators[0]["private_key"]
voter_keys = [v["private_key"] for v in validators]
election, votes = generate_election(b, ChainMigrationElection, public_key, private_key, {}, voter_keys)
election, votes = generate_election(b, ChainMigrationElection, public_key, private_key, [{"data": {}}], voter_keys)
txs = [election]
total_votes = votes
election, votes = generate_election(b, ChainMigrationElection, public_key, private_key, {}, voter_keys)
election, votes = generate_election(b, ChainMigrationElection, public_key, private_key, [{"data": {}}], voter_keys)
txs += [election]
total_votes += votes

2
tests/migrations/test_migration_election.py
View File

@ -3,5 +3,5 @@ from transactions.types.elections.chain_migration_election import ChainMigration
def test_valid_migration_election(b_mock, node_key):
voters = b_mock.get_recipients_list()
election = ChainMigrationElection.generate([node_key.public_key], voters, {}, None).sign([node_key.private_key])
election = ChainMigrationElection.generate([node_key.public_key], voters, [{"data": {}}], None).sign([node_key.private_key])
assert b_mock.validate_election(election)

6
tests/tendermint/test_core.py
View File

@ -318,7 +318,7 @@ def test_end_block_return_validator_updates(b, init_chain_request):
voter_keys = [v["private_key"] for v in validators]
election, votes = generate_election(
b, ValidatorElection, public_key, private_key, new_validator["election"], voter_keys
b, ValidatorElection, public_key, private_key, [{"data": new_validator["election"]}], voter_keys
)
b.store_block(Block(height=1, transactions=[election.id], app_hash="")._asdict())
b.store_bulk_transactions([election])
@ -379,14 +379,14 @@ def test_rollback_pre_commit_state_after_crash(b):
private_key = validators[0]["private_key"]
voter_keys = [v["private_key"] for v in validators]
migration_election, votes = generate_election(b, ChainMigrationElection, public_key, private_key, {}, voter_keys)
migration_election, votes = generate_election(b, ChainMigrationElection, public_key, private_key, [{"data": {}}], voter_keys)
total_votes = votes
txs = [migration_election, *votes]
new_validator = generate_validators([1])[0]
validator_election, votes = generate_election(
b, ValidatorElection, public_key, private_key, new_validator["election"], voter_keys
b, ValidatorElection, public_key, private_key, [{"data": new_validator["election"]}], voter_keys
)
total_votes += votes

2
tests/tendermint/test_lib.py
View File

@ -229,7 +229,7 @@ def test_store_bulk_transaction(mocker, b, signed_create_tx, signed_transfer_tx,
if isinstance(b.connection, TarantoolDBConnection):
mocked_store_assets.assert_called_once_with(
b.connection, # signed_create_tx.asset['data'] this was before
[(signed_create_tx.asset, signed_create_tx.id, signed_create_tx.id)],
[(signed_create_tx.assets[0], signed_create_tx.id, signed_create_tx.id)],
)
else:
mocked_store_assets.assert_called_once_with(

3
tests/test_docs.py
View File

@ -4,8 +4,9 @@
# Code is Apache-2.0 and docs are CC-BY-4.0
import subprocess
import pytest
@pytest.mark.skip
def test_build_root_docs():
proc = subprocess.Popen(["bash"], stdin=subprocess.PIPE)
proc.stdin.write("cd docs/root; make html".encode())

54
tests/upsert_validator/test_upsert_validator_vote.py
View File

@ -30,7 +30,7 @@ def test_upsert_validator_valid_election_vote(b_mock, valid_upsert_validator_ele
election_pub_key = election_id_to_public_key(valid_upsert_validator_election.id)
vote = Vote.generate([input0], [([election_pub_key], votes)], election_id=valid_upsert_validator_election.id).sign(
vote = Vote.generate([input0], [([election_pub_key], votes)], election_ids=[valid_upsert_validator_election.id]).sign(
[key0.private_key]
)
assert b_mock.validate_transaction(vote)
@ -50,7 +50,7 @@ def test_upsert_validator_valid_non_election_vote(b_mock, valid_upsert_validator
# Ensure that threshold conditions are now allowed
with pytest.raises(ValidationError):
Vote.generate(
[input0], [([election_pub_key, key0.public_key], votes)], election_id=valid_upsert_validator_election.id
[input0], [([election_pub_key, key0.public_key], votes)], election_ids=[valid_upsert_validator_election.id]
).sign([key0.private_key])
@ -68,7 +68,7 @@ def test_upsert_validator_delegate_election_vote(b_mock, valid_upsert_validator_
delegate_vote = Vote.generate(
[input0],
[([alice.public_key], 3), ([key0.public_key], votes - 3)],
election_id=valid_upsert_validator_election.id,
election_ids=[valid_upsert_validator_election.id],
).sign([key0.private_key])
assert b_mock.validate_transaction(delegate_vote)
@ -78,13 +78,13 @@ def test_upsert_validator_delegate_election_vote(b_mock, valid_upsert_validator_
alice_votes = delegate_vote.to_inputs()[0]
alice_casted_vote = Vote.generate(
[alice_votes], [([election_pub_key], 3)], election_id=valid_upsert_validator_election.id
[alice_votes], [([election_pub_key], 3)], election_ids=[valid_upsert_validator_election.id]
).sign([alice.private_key])
assert b_mock.validate_transaction(alice_casted_vote)
key0_votes = delegate_vote.to_inputs()[1]
key0_casted_vote = Vote.generate(
[key0_votes], [([election_pub_key], votes - 3)], election_id=valid_upsert_validator_election.id
[key0_votes], [([election_pub_key], votes - 3)], election_ids=[valid_upsert_validator_election.id]
).sign([key0.private_key])
assert b_mock.validate_transaction(key0_casted_vote)
@ -101,7 +101,7 @@ def test_upsert_validator_invalid_election_vote(b_mock, valid_upsert_validator_e
election_pub_key = election_id_to_public_key(valid_upsert_validator_election.id)
vote = Vote.generate(
[input0], [([election_pub_key], votes + 1)], election_id=valid_upsert_validator_election.id
[input0], [([election_pub_key], votes + 1)], election_ids=[valid_upsert_validator_election.id]
).sign([key0.private_key])
with pytest.raises(AmountError):
@ -123,7 +123,7 @@ def test_valid_election_votes_received(b_mock, valid_upsert_validator_election,
delegate_vote = Vote.generate(
[input0],
[([alice.public_key], 4), ([key0.public_key], votes - 4)],
election_id=valid_upsert_validator_election.id,
election_ids=[valid_upsert_validator_election.id],
).sign([key0.private_key])
b_mock.store_bulk_transactions([delegate_vote])
assert b_mock.get_commited_votes(valid_upsert_validator_election) == 0
@ -135,7 +135,7 @@ def test_valid_election_votes_received(b_mock, valid_upsert_validator_election,
alice_casted_vote = Vote.generate(
[alice_votes],
[([election_public_key], 2), ([alice.public_key], 2)],
election_id=valid_upsert_validator_election.id,
election_ids=[valid_upsert_validator_election.id],
).sign([alice.private_key])
assert b_mock.validate_transaction(alice_casted_vote)
@ -145,7 +145,7 @@ def test_valid_election_votes_received(b_mock, valid_upsert_validator_election,
assert b_mock.get_commited_votes(valid_upsert_validator_election) == 2
key0_casted_vote = Vote.generate(
[key0_votes], [([election_public_key], votes - 4)], election_id=valid_upsert_validator_election.id
[key0_votes], [([election_public_key], votes - 4)], election_ids=[valid_upsert_validator_election.id]
).sign([key0.private_key])
assert b_mock.validate_transaction(key0_casted_vote)
@ -230,11 +230,13 @@ def test_upsert_validator(b, node_key, node_keys, ed25519_node_keys):
power = 1
public_key = "9B3119650DF82B9A5D8A12E38953EA47475C09F0C48A4E6A0ECE182944B24403"
public_key64 = public_key_to_base64(public_key)
new_validator = {
"public_key": {"value": public_key, "type": "ed25519-base16"},
"node_id": "some_node_id",
"power": power,
}
new_validator = [{
"data": {
"public_key": {"value": public_key, "type": "ed25519-base16"},
"node_id": "some_node_id",
"power": power,
}
}]
voters = b.get_recipients_list()
election = ValidatorElection.generate([node_key.public_key], voters, new_validator, None).sign(
@ -270,11 +272,13 @@ def test_get_validator_update(b, node_keys, node_key, ed25519_node_keys):
power = 1
public_key = "9B3119650DF82B9A5D8A12E38953EA47475C09F0C48A4E6A0ECE182944B24403"
public_key64 = public_key_to_base64(public_key)
new_validator = {
"public_key": {"value": public_key, "type": "ed25519-base16"},
"node_id": "some_node_id",
"power": power,
}
new_validator = [{
"data": {
"public_key": {"value": public_key, "type": "ed25519-base16"},
"node_id": "some_node_id",
"power": power,
}
}]
voters = b.get_recipients_list()
election = ValidatorElection.generate([node_key.public_key], voters, new_validator).sign([node_key.private_key])
# store election
@ -298,11 +302,13 @@ def test_get_validator_update(b, node_keys, node_key, ed25519_node_keys):
# remove validator
power = 0
new_validator = {
"public_key": {"value": public_key, "type": "ed25519-base16"},
"node_id": "some_node_id",
"power": power,
}
new_validator = [{
"data":{
"public_key": {"value": public_key, "type": "ed25519-base16"},
"node_id": "some_node_id",
"power": power,
}
}]
voters = b.get_recipients_list()
election = ValidatorElection.generate([node_key.public_key], voters, new_validator).sign([node_key.private_key])
# store election

4
tests/upsert_validator/test_validator_election.py
View File

@ -32,7 +32,7 @@ def test_upsert_validator_invalid_election_public_key(b_mock, new_validator, nod
from transactions.common.exceptions import InvalidPublicKey
for iv in ["ed25519-base32", "ed25519-base64"]:
new_validator["public_key"]["type"] = iv
new_validator[0]["data"]["public_key"]["type"] = iv
voters = b_mock.get_recipients_list()
with pytest.raises(InvalidPublicKey):
@ -41,7 +41,7 @@ def test_upsert_validator_invalid_election_public_key(b_mock, new_validator, nod
def test_upsert_validator_invalid_power_election(b_mock, new_validator, node_key):
voters = b_mock.get_recipients_list()
new_validator["power"] = 30
new_validator[0]["data"]["power"] = 30
election = ValidatorElection.generate([node_key.public_key], voters, new_validator, None).sign(
[node_key.private_key]

4
tests/utils.py
View File

@ -74,7 +74,7 @@ def to_inputs(election, i, ed25519_node_keys):
def gen_vote(election, i, ed25519_node_keys):
(input_i, votes_i, key_i) = to_inputs(election, i, ed25519_node_keys)
election_pub_key = election_id_to_public_key(election.id)
return Vote.generate([input_i], [([election_pub_key], votes_i)], election_id=election.id).sign([key_i.private_key])
return Vote.generate([input_i], [([election_pub_key], votes_i)], election_ids=[election.id]).sign([key_i.private_key])
def generate_validators(powers):
@ -123,7 +123,7 @@ def generate_election(b, cls, public_key, private_key, asset_data, voter_keys):
election = cls.generate([public_key], voters, asset_data, None).sign([private_key])
votes = [
Vote.generate([election.to_inputs()[i]], [([election_id_to_public_key(election.id)], power)], election.id)
Vote.generate([election.to_inputs()[i]], [([election_id_to_public_key(election.id)], power)], [election.id])
for i, (_, power) in enumerate(voters)
]
for key, v in zip(voter_keys, votes):

2
tests/validation/test_transaction_structure.py
View File

@ -246,7 +246,7 @@ def test_unsupported_condition_type():
def test_validate_version(b, create_tx, alice):
create_tx.version = "2.0"
create_tx.version = "3.0"
create_tx.sign([alice.private_key])
validate(create_tx)

4
tests/web/test_assets.py
View File

@ -56,11 +56,11 @@ def test_get_assets_limit_tendermint(client, b, alice):
b.store_bulk_transactions([tx2])
# test that both assets are returned without limit
res = client.get(ASSETS_ENDPOINT + "?search=" + asset1["data"])
res = client.get(ASSETS_ENDPOINT + "?search=" + assets1[0]["data"])
assert res.status_code == 200
assert len(res.json) == 1
# test that only one asset is returned when using limit=1
res = client.get(ASSETS_ENDPOINT + "?search=" + asset1["data"] + "&limit=1")
res = client.get(ASSETS_ENDPOINT + "?search=" + assets1[0]["data"] + "&limit=1")
assert res.status_code == 200
assert len(res.json) == 1