You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
241 lines
8.4 KiB
241 lines
8.4 KiB
import pytest
|
|
|
|
from pyhmy import transaction
|
|
|
|
from pyhmy.rpc import exceptions
|
|
|
|
|
|
endpoint = "http://localhost:9500"
|
|
endpoint_shard_one = "http://localhost:9502"
|
|
fake_shard = "http://example.com"
|
|
|
|
# previously sent txs to get and check
|
|
tx_hash = "0xc26be5776aa57438bccf196671a2d34f3f22c9c983c0f844c62b2fb90403aa43"
|
|
tx_block_num = None
|
|
tx_block_hash = None
|
|
tx_index = None
|
|
|
|
cx_hash = "0xf73ba634cb96fc0e3e2c9d3b4c91379e223741be4a5aa56e6d6caf49c1ae75cf"
|
|
|
|
stx_hash = "0xc8177ace2049d9f4eb4a45fd6bd6b16f693573d036322c36774cc00d05a3e24f"
|
|
stx_block_num = None
|
|
stx_block_hash = None
|
|
stx_index = None
|
|
|
|
# new txs to send and check
|
|
raw_tx = "0xf86f0385174876e800825208808094c9c6d47ee5f2e3e08d7367ad1a1373ba9dd172418905b12aefafa80400008027a07a4952b90bf38723a9197179a8e6d2e9b3a86fd6da4e66a9cf09fdc59783f757a053910798b311245525bd77d6119332458c2855102e4fb9e564f6a3b710d18bb0"
|
|
raw_tx_hash = "0x7ccd80f8513f76ec58b357c7a82a12a95e025d88f1444e953f90e3d86e222571"
|
|
|
|
raw_stx = "0xf88302f494c9c6d47ee5f2e3e08d7367ad1a1373ba9dd1724194a5241513da9f4463f1d4874b548dfbac29d91f3489056bc75e2d631000008085174876e80082c35027a0808ea7d27adf3b1f561e8da4676814084bb75ac541b616bece87c6446e6cc54ea02f19f0b14240354bd42ad60b0c7189873c0be87044e13072b0981a837ca76f64"
|
|
raw_stx_hash = "0xe7d07ef6d9fca595a14ceb0ca917bece7bedb15efe662300e9334a32ac1da629"
|
|
|
|
|
|
def _test_transaction_rpc(fn, *args, **kwargs):
|
|
if not callable(fn):
|
|
pytest.fail(f"Invalid function: {fn}")
|
|
|
|
try:
|
|
response = fn(*args, **kwargs)
|
|
except Exception as e:
|
|
if isinstance(
|
|
e, exceptions.RPCError
|
|
) and "does not exist/is not available" in str(e):
|
|
pytest.skip(f"{str(e)}")
|
|
pytest.fail(f"Unexpected error: {e.__class__} {e}")
|
|
return response
|
|
|
|
|
|
def test_get_pending_transactions(setup_blockchain):
|
|
pool = _test_transaction_rpc(transaction.get_pending_transactions)
|
|
assert isinstance(pool, list)
|
|
|
|
|
|
def test_get_transaction_by_hash(setup_blockchain):
|
|
tx = _test_transaction_rpc(
|
|
transaction.get_transaction_by_hash, tx_hash, endpoint=endpoint
|
|
)
|
|
assert tx
|
|
assert isinstance(tx, dict)
|
|
assert "blockNumber" in tx.keys()
|
|
assert "blockHash" in tx.keys()
|
|
global tx_block_num
|
|
tx_block_num = int(tx["blockNumber"])
|
|
global tx_block_hash
|
|
tx_block_hash = tx["blockHash"]
|
|
global tx_index
|
|
tx_index = int(tx["transactionIndex"])
|
|
|
|
|
|
def test_get_transaction_by_block_hash_and_index(setup_blockchain):
|
|
if not tx_block_hash:
|
|
pytest.skip("Failed to get reference block hash")
|
|
tx = _test_transaction_rpc(
|
|
transaction.get_transaction_by_block_hash_and_index,
|
|
tx_block_hash,
|
|
tx_index,
|
|
endpoint=endpoint,
|
|
)
|
|
assert tx
|
|
assert isinstance(tx, dict)
|
|
|
|
|
|
def test_get_transaction_by_block_number_and_index(setup_blockchain):
|
|
if not tx_block_num:
|
|
pytest.skip("Failed to get reference block num")
|
|
tx = _test_transaction_rpc(
|
|
transaction.get_transaction_by_block_number_and_index,
|
|
tx_block_num,
|
|
tx_index,
|
|
endpoint=endpoint,
|
|
)
|
|
assert tx
|
|
assert isinstance(tx, dict)
|
|
|
|
|
|
def test_get_transaction_receipt(setup_blockchain):
|
|
tx_receipt = _test_transaction_rpc(
|
|
transaction.get_transaction_receipt, tx_hash, endpoint=endpoint
|
|
)
|
|
assert tx_receipt
|
|
assert isinstance(tx_receipt, dict)
|
|
|
|
|
|
def test_get_transaction_error_sink(setup_blockchain):
|
|
errors = _test_transaction_rpc(transaction.get_transaction_error_sink)
|
|
assert isinstance(errors, list)
|
|
|
|
|
|
def test_send_and_confirm_raw_transaction(setup_blockchain):
|
|
# Note: this test is not yet idempotent since the localnet will reject transactions which were previously finalized.
|
|
test_tx = _test_transaction_rpc(
|
|
transaction.send_and_confirm_raw_transaction, raw_tx
|
|
)
|
|
assert isinstance(test_tx, dict)
|
|
assert test_tx["hash"] == raw_tx_hash
|
|
|
|
|
|
def test_get_pending_cx_receipts(setup_blockchain):
|
|
pending = _test_transaction_rpc(transaction.get_pending_cx_receipts)
|
|
assert isinstance(pending, list)
|
|
|
|
|
|
def test_get_cx_receipt_by_hash(setup_blockchain):
|
|
cx = _test_transaction_rpc(
|
|
transaction.get_cx_receipt_by_hash, cx_hash, endpoint_shard_one
|
|
)
|
|
assert cx
|
|
assert isinstance(cx, dict)
|
|
|
|
|
|
def test_resend_cx_receipt(setup_blockchain):
|
|
sent = _test_transaction_rpc(transaction.resend_cx_receipt, cx_hash)
|
|
assert isinstance(sent, bool)
|
|
assert sent
|
|
|
|
|
|
def test_get_staking_transaction_by_hash(setup_blockchain):
|
|
staking_tx = _test_transaction_rpc(
|
|
transaction.get_staking_transaction_by_hash, stx_hash
|
|
)
|
|
assert staking_tx
|
|
assert isinstance(staking_tx, dict)
|
|
assert "blockNumber" in staking_tx.keys()
|
|
assert "blockHash" in staking_tx.keys()
|
|
global stx_block_num
|
|
stx_block_num = int(staking_tx["blockNumber"])
|
|
global stx_block_hash
|
|
stx_block_hash = staking_tx["blockHash"]
|
|
global stx_index
|
|
stx_index = int(staking_tx["transactionIndex"])
|
|
|
|
|
|
def test_get_transaction_by_block_hash_and_index(setup_blockchain):
|
|
if not stx_block_hash:
|
|
pytest.skip("Failed to get reference block hash")
|
|
stx = _test_transaction_rpc(
|
|
transaction.get_staking_transaction_by_block_hash_and_index,
|
|
stx_block_hash,
|
|
stx_index,
|
|
)
|
|
assert stx
|
|
assert isinstance(stx, dict)
|
|
|
|
|
|
def test_get_transaction_by_block_number_and_index(setup_blockchain):
|
|
if not stx_block_num:
|
|
pytest.skip("Failed to get reference block num")
|
|
stx = _test_transaction_rpc(
|
|
transaction.get_staking_transaction_by_block_number_and_index,
|
|
stx_block_num,
|
|
stx_index,
|
|
)
|
|
assert stx
|
|
assert isinstance(stx, dict)
|
|
|
|
|
|
def test_get_staking_transaction_error_sink(setup_blockchain):
|
|
errors = _test_transaction_rpc(transaction.get_staking_transaction_error_sink)
|
|
assert isinstance(errors, list)
|
|
|
|
|
|
def test_send_raw_staking_transaction(setup_blockchain):
|
|
test_stx = _test_transaction_rpc(
|
|
transaction.send_and_confirm_raw_staking_transaction, raw_stx, endpoint=endpoint
|
|
)
|
|
assert isinstance(test_stx, dict)
|
|
assert test_stx["hash"] == raw_stx_hash
|
|
|
|
|
|
def test_get_pool_stats(setup_blockchain):
|
|
test_pool_stats = _test_transaction_rpc(
|
|
transaction.get_pool_stats, endpoint=endpoint
|
|
)
|
|
assert isinstance(test_pool_stats, dict)
|
|
|
|
|
|
def test_get_pending_staking_transactions(setup_blockchain):
|
|
pending_staking_transactions = _test_transaction_rpc(
|
|
transaction.get_pending_staking_transactions, endpoint=endpoint
|
|
)
|
|
assert isinstance(pending_staking_transactions, list)
|
|
|
|
|
|
def test_errors():
|
|
with pytest.raises(exceptions.RPCError):
|
|
transaction.get_pending_transactions(fake_shard)
|
|
with pytest.raises(exceptions.RPCError):
|
|
transaction.get_transaction_error_sink(fake_shard)
|
|
with pytest.raises(exceptions.RPCError):
|
|
transaction.get_pool_stats(fake_shard)
|
|
with pytest.raises(exceptions.RPCError):
|
|
transaction.get_transaction_by_hash("", endpoint=fake_shard)
|
|
with pytest.raises(exceptions.RPCError):
|
|
transaction.get_transaction_by_block_hash_and_index("", 1, endpoint=fake_shard)
|
|
with pytest.raises(exceptions.RPCError):
|
|
transaction.get_transaction_by_block_number_and_index(1, 1, endpoint=fake_shard)
|
|
with pytest.raises(exceptions.RPCError):
|
|
transaction.get_transaction_receipt("", endpoint=fake_shard)
|
|
with pytest.raises(exceptions.RPCError):
|
|
transaction.send_raw_transaction("", endpoint=fake_shard)
|
|
with pytest.raises(exceptions.RPCError):
|
|
transaction.get_pending_cx_receipts(fake_shard)
|
|
with pytest.raises(exceptions.RPCError):
|
|
transaction.get_cx_receipt_by_hash("", endpoint=fake_shard)
|
|
with pytest.raises(exceptions.RPCError):
|
|
transaction.resend_cx_receipt("", endpoint=fake_shard)
|
|
with pytest.raises(exceptions.RPCError):
|
|
transaction.get_staking_transaction_by_hash("", endpoint=fake_shard)
|
|
with pytest.raises(exceptions.RPCError):
|
|
transaction.get_staking_transaction_by_block_hash_and_index(
|
|
"", 1, endpoint=fake_shard
|
|
)
|
|
with pytest.raises(exceptions.RPCError):
|
|
transaction.get_staking_transaction_by_block_number_and_index(
|
|
1, 1, endpoint=fake_shard
|
|
)
|
|
with pytest.raises(exceptions.RPCError):
|
|
transaction.get_staking_transaction_error_sink(endpoint=fake_shard)
|
|
with pytest.raises(exceptions.RPCError):
|
|
transaction.send_raw_staking_transaction("", endpoint=fake_shard)
|
|
with pytest.raises(exceptions.RPCError):
|
|
transaction.get_pending_staking_transactions(endpoint=fake_shard)
|
|
|