[tests] Update tests to assert return type

pyhmy/rpc/blockchain.py

@@ -503,7 +503,7 @@ def get_validators(epoch, endpoint=_default_endpoint, timeout=_default_timeout)
     return rpc_request('hmy_getValidators', params=params, endpoint=endpoint, timeout=timeout)['result']
 
 
-def get_bad_blocks(endpoint=_default_endpoint, timeout=_default_timeout) -> dict:
+def get_bad_blocks(endpoint=_default_endpoint, timeout=_default_timeout) -> list:
     """
     Get list of bad blocks in memory of specific node
 

tests/rpc-pyhmy/test_account.py

@@ -33,39 +33,47 @@ def _test_account_rpc(fn, *args, **kwargs):
 @pytest.mark.run(order=1)
 def test_get_balance(setup_blockchain):
     balance = _test_account_rpc(account.get_balance, local_test_address)
+    assert isinstance(balance, int)
     assert balance > 0
 
 @pytest.mark.run(order=2)
 def test_get_balance_by_block(setup_blockchain):
     balance = _test_account_rpc(account.get_balance_by_block, local_test_address, genesis_block_number)
+    assert isinstance(balance, int)
     assert balance > 0
 
 @pytest.mark.run(order=3)
 def test_get_true_nonce(setup_blockchain):
     true_nonce = _test_account_rpc(account.get_account_nonce, local_test_address, true_nonce=True, endpoint=endpoint_shard_one)
+    assert isinstance(true_nonce, int)
     assert true_nonce > 0
 
 @pytest.mark.run(order=4)
 def test_get_pending_nonce(setup_blockchain):
     pending_nonce = _test_account_rpc(account.get_account_nonce, local_test_address, endpoint=endpoint_shard_one)
+    assert isinstance(pending_nonce, int)
     assert pending_nonce > 0
 
 @pytest.mark.run(order=5)
 def test_get_transaction_history(setup_blockchain):
     tx_history = _test_account_rpc(account.get_transaction_history, local_test_address, endpoint=explorer_endpoint)
+    assert isinstance(tx_history, list)
     assert len(tx_history) >= 0
 
 @pytest.mark.run(order=6)
 def test_get_staking_transaction_history(setup_blockchain):
     staking_tx_history = _test_account_rpc(account.get_staking_transaction_history, test_validator_address, endpoint=explorer_endpoint)
+    assert isinstance(staking_tx_history, list)
     assert len(staking_tx_history) > 0
 
 @pytest.mark.run(order=7)
 def test_get_balance_on_all_shards(setup_blockchain):
     balances = _test_account_rpc(account.get_balance_on_all_shards, local_test_address)
+    assert isinstance(balances, list)
     assert len(balances) == 2
 
 @pytest.mark.run(order=8)
 def test_get_total_balance(setup_blockchain):
     total_balance = _test_account_rpc(account.get_total_balance, local_test_address)
+    assert isinstance(total_balance, int)
     assert total_balance > 0

tests/rpc-pyhmy/test_blockchain.py

@@ -29,89 +29,116 @@ def _test_blockchain_rpc(fn, *args, **kwargs):
 
 @pytest.mark.run(order=1)
 def test_get_node_metadata(setup_blockchain):
-    _test_blockchain_rpc(blockchain.get_node_metadata)
+    metadata = _test_blockchain_rpc(blockchain.get_node_metadata)
+    assert isinstance(metadata, dict)
 
 @pytest.mark.run(order=2)
 def test_get_sharding_structure(setup_blockchain):
-    _test_blockchain_rpc(blockchain.get_sharding_structure)
+    sharding_structure = _test_blockchain_rpc(blockchain.get_sharding_structure)
+    assert isinstance(sharding_structure, list)
+    assert len(sharding_structure) > 0
 
 @pytest.mark.run(order=3)
 def test_get_leader_address(setup_blockchain):
-    _test_blockchain_rpc(blockchain.get_leader_address)
+    leader = _test_blockchain_rpc(blockchain.get_leader_address)
+    assert isinstance(leader, str)
+    assert 'one1' in leader
 
 @pytest.mark.run(order=4)
 def test_get_block_number(setup_blockchain):
-    _test_blockchain_rpc(blockchain.get_block_number)
+    current_block_number = _test_blockchain_rpc(blockchain.get_block_number)
+    assert isinstance(current_block_number, int)
 
 @pytest.mark.run(order=5)
 def test_get_current_epoch(setup_blockchain):
-    _test_blockchain_rpc(blockchain.get_current_epoch)
+    current_epoch = _test_blockchain_rpc(blockchain.get_current_epoch)
+    assert isinstance(current_epoch, int)
 
 @pytest.mark.run(order=6)
 def tset_get_gas_price(setup_blockchain):
-    _test_blockchain_rpc(blockchain.get_gas_price)
+    gas = _test_blockchain_rpc(blockchain.get_gas_price)
+    assert isinstance(gas, int)
 
 @pytest.mark.run(order=7)
 def test_get_num_peers(setup_blockchain):
-    _test_blockchain_rpc(blockchain.get_num_peers)
+    peers = _test_blockchain_rpc(blockchain.get_num_peers)
+    assert isinstance(peers, int)
 
 @pytest.mark.run(order=8)
 def test_get_latest_header(setup_blockchain):
-    _test_blockchain_rpc(blockchain.get_latest_header)
+    header = _test_blockchain_rpc(blockchain.get_latest_header)
+    assert isinstance(header, dict)
 
 @pytest.mark.run(order=9)
 def test_get_latest_headers(setup_blockchain):
-    _test_blockchain_rpc(blockchain.get_latest_headers)
+    header_pair = _test_blockchain_rpc(blockchain.get_latest_headers)
+    assert isinstance(header_pair, dict)
 
 @pytest.mark.run(order=10)
 def test_get_block_by_number(setup_blockchain):
     global test_block_hash
     block = _test_blockchain_rpc(blockchain.get_block_by_number, test_block_number)
+    assert isinstance(block, dict)
+    assert 'hash' in block.keys()
     test_block_hash = block['hash']
 
 @pytest.mark.run(order=11)
 def test_get_block_by_hash(setup_blockchain):
     if not test_block_hash:
         pytest.skip('Failed to get reference block hash')
-    _test_blockchain_rpc(blockchain.get_block_by_hash, test_block_hash)
+    block = _test_blockchain_rpc(blockchain.get_block_by_hash, test_block_hash)
+    assert isinstance(block, dict)
 
 @pytest.mark.run(order=12)
 def test_get_block_transaction_count_by_number(setup_blockchain):
-    _test_blockchain_rpc(blockchain.get_block_transaction_count_by_number, test_block_number)
+    tx_count = _test_blockchain_rpc(blockchain.get_block_transaction_count_by_number, test_block_number)
+    assert isinstance(tx_count, int)
 
 @pytest.mark.run(order=13)
 def test_get_block_transaction_count_by_hash(setup_blockchain):
     if not test_block_hash:
         pytest.skip('Failed to get reference block hash')
-    _test_blockchain_rpc(blockchain.get_block_transaction_count_by_hash, test_block_hash)
+    tx_count = _test_blockchain_rpc(blockchain.get_block_transaction_count_by_hash, test_block_hash)
+    assert isinstance(tx_count, int)
 
 @pytest.mark.run(order=14)
 def test_get_blocks(setup_blockchain):
-    _test_blockchain_rpc(blockchain.get_blocks, genesis_block_number, test_block_number)
+    blocks = _test_blockchain_rpc(blockchain.get_blocks, genesis_block_number, test_block_number)
+    assert isinstance(blocks, list)
+    assert len(blocks) == (test_block_number - genesis_block_number + 1)
 
 @pytest.mark.run(order=15)
 def test_get_block_signers(setup_blockchain):
-    _test_blockchain_rpc(blockchain.get_block_signers, test_block_number)
+    block_signers = _test_blockchain_rpc(blockchain.get_block_signers, test_block_number)
+    assert isinstance(block_signers, list)
+    assert len(block_signers) > 0
 
 @pytest.mark.run(order=16)
 def test_get_validators(setup_blockchain):
-    _test_blockchain_rpc(blockchain.get_validators, test_epoch_number)
+    validators = _test_blockchain_rpc(blockchain.get_validators, test_epoch_number)
+    assert isinstance(validators, dict)
+    assert 'validators' in validators.keys()
+    assert len(validators['validators']) > 0
 
 @pytest.mark.run(order=17)
 def test_get_shard(setup_blockchain):
     shard = _test_blockchain_rpc(blockchain.get_shard)
+    assert isinstance(shard, int)
     assert shard == 0
 
 @pytest.mark.run(order=18)
 def test_get_staking_epoch(setup_blockchain):
-    _test_blockchain_rpc(blockchain.get_staking_epoch)
+    staking_epoch = _test_blockchain_rpc(blockchain.get_staking_epoch)
+    assert isinstance(staking_epoch, int)
 
 @pytest.mark.run(order=19)
 def test_get_prestaking_epoch(setup_blockchain):
-    _test_blockchain_rpc(blockchain.get_prestaking_epoch)
+    prestaking_epoch = _test_blockchain_rpc(blockchain.get_prestaking_epoch)
+    assert isinstance(prestaking_epoch, int)
 
 @pytest.mark.run(order=20)
 def test_get_bad_blocks(setup_blockchain):
     # TODO: Remove skip when RPC is fixed
     pytest.skip("Known error with hmy_getCurrentBadBlocks")
-    _test_blockchain_rpc(blockchain.get_bad_blocks)
+    bad_blocks = _test_blockchain_rpc(blockchain.get_bad_blocks)
+    assert isinstance(bad_blocks, list)

tests/rpc-pyhmy/test_staking.py

@@ -28,54 +28,66 @@ def _test_staking_rpc(fn, *args, **kwargs):
 @pytest.mark.run(order=1)
 def test_get_all_validator_addresses(setup_blockchain):
     validator_addresses = _test_staking_rpc(staking.get_all_validator_addresses)
+    assert isinstance(validator_addresses, list)
     assert len(validator_addresses) > 0
     assert test_validator_address in validator_addresses
 
 @pytest.mark.run(order=2)
 def test_get_validator_information(setup_blockchain):
-    _test_staking_rpc(staking.get_validator_information, test_validator_address)
+    info = _test_staking_rpc(staking.get_validator_information, test_validator_address)
+    assert isinstance(info, dict)
 
 @pytest.mark.run(order=3)
 def test_get_all_validator_information(setup_blockchain):
     all_validator_information = _test_staking_rpc(staking.get_all_validator_information)
+    assert isinstance(all_validator_information, list)
     assert len(all_validator_information) > 0
 
 @pytest.mark.run(order=4)
 def test_get_delegations_by_delegator(setup_blockchain):
     delegations = _test_staking_rpc(staking.get_delegations_by_delegator, test_validator_address)
+    assert isinstance(delegations, list)
     assert len(delegations) > 0
 
 @pytest.mark.run(order=5)
 def test_get_delegations_by_validator(setup_blockchain):
     delegations = _test_staking_rpc(staking.get_delegations_by_validator, test_validator_address)
+    assert isinstance(delegations, list)
     assert len(delegations) > 0
 
 @pytest.mark.run(order=6)
 def test_get_current_utility_metrics(setup_blockchain):
-    _test_staking_rpc(staking.get_current_utility_metrics)
+    metrics = _test_staking_rpc(staking.get_current_utility_metrics)
+    assert isinstance(metrics, dict)
 
 @pytest.mark.run(order=7)
 def test_get_staking_network_info(setup_blockchain):
-    _test_staking_rpc(staking.get_staking_network_info)
+    info = _test_staking_rpc(staking.get_staking_network_info)
+    assert isinstance(info, dict)
 
 @pytest.mark.run(order=8)
 def test_get_super_committees(setup_blockchain):
-    _test_staking_rpc(staking.get_super_committees)
+    committee = _test_staking_rpc(staking.get_super_committees)
+    assert isinstance(committee, dict)
 
 @pytest.mark.run(order=9)
 def test_get_raw_median_stake_snapshot(setup_blockchain):
-    _test_staking_rpc(staking.get_raw_median_stake_snapshot)
+    median_stake = _test_staking_rpc(staking.get_raw_median_stake_snapshot)
+    assert isinstance(median_stake, dict)
 
 @pytest.mark.run(order=10)
 def test_get_validator_information_by_block(setup_blockchain):
     # Apparently validator information not created until block after create-validator transaction is accepted, so +1 block
-    _test_staking_rpc(staking.get_validator_information_by_block, test_validator_address, setup_blockchain + 1, endpoint=explorer_endpoint)
+    info = _test_staking_rpc(staking.get_validator_information_by_block, test_validator_address, setup_blockchain + 1, endpoint=explorer_endpoint)
+    assert isinstance(info, dict)
 
 @pytest.mark.run(order=11)
 def test_get_validator_information_by_block(setup_blockchain):
     # Apparently validator information not created until block after create-validator transaction is accepted, so +1 block
-    _test_staking_rpc(staking.get_all_validator_information_by_block, setup_blockchain + 1, endpoint=explorer_endpoint)
+    info = _test_staking_rpc(staking.get_all_validator_information_by_block, setup_blockchain + 1, endpoint=explorer_endpoint)
+    assert isinstance(info, list)
 
 @pytest.mark.run(order=12)
 def test_get_delegations_by_delegator_by_block(setup_blockchain):
-    _test_staking_rpc(staking.get_delegations_by_delegator_by_block, test_validator_address, setup_blockchain + 1, endpoint=explorer_endpoint)
+    delegations = _test_staking_rpc(staking.get_delegations_by_delegator_by_block, test_validator_address, setup_blockchain + 1, endpoint=explorer_endpoint)
+    assert isinstance(delegations, list)

tests/rpc-pyhmy/test_transaction.py

@@ -37,12 +37,16 @@ def _test_transaction_rpc(fn, *args, **kwargs):
 
 @pytest.mark.run(order=1)
 def test_get_pending_transactions(setup_blockchain):
-    _test_transaction_rpc(transaction.get_pending_transactions)
+    pool = _test_transaction_rpc(transaction.get_pending_transactions)
+    assert isinstance(pool, list)
 
 @pytest.mark.run(order=2)
 def test_get_transaction_by_hash(setup_blockchain):
     tx = _test_transaction_rpc(transaction.get_transaction_by_hash, tx_hash, endpoint=localhost_shard_one)
-    assert tx is not None
+    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'], 0)
     global tx_block_hash
@@ -54,7 +58,8 @@ def test_get_transaction_by_block_hash_and_index(setup_blockchain):
         pytest.skip('Failed to get reference block hash')
     tx = _test_transaction_rpc(transaction.get_transaction_by_block_hash_and_index,
                                tx_block_hash, test_index, endpoint=localhost_shard_one)
-    assert tx is not None
+    assert tx
+    assert isinstance(tx, dict)
 
 @pytest.mark.run(order=4)
 def test_get_transaction_by_block_number_and_index(setup_blockchain):
@@ -62,40 +67,50 @@ def test_get_transaction_by_block_number_and_index(setup_blockchain):
         pytest.skip('Failed to get reference block num')
     tx = _test_transaction_rpc(transaction.get_transaction_by_block_number_and_index, tx_block_num, test_index,
                                endpoint=localhost_shard_one)
-    assert tx is not None
+    assert tx
+    assert isinstance(tx, dict)
 
 @pytest.mark.run(order=5)
 def test_get_transaction_receipt(setup_blockchain):
     tx_receipt = _test_transaction_rpc(transaction.get_transaction_receipt, tx_hash, endpoint=localhost_shard_one)
-    assert tx_receipt is not None
+    assert tx_receipt
+    assert isinstance(tx_receipt, dict)
 
 @pytest.mark.run(order=6)
 def test_get_transaction_error_sink(setup_blockchain):
-    _test_transaction_rpc(transaction.get_transaction_error_sink)
+    errors = _test_transaction_rpc(transaction.get_transaction_error_sink)
+    assert isinstance(errors, list)
 
 @pytest.mark.run(order=7)
 def test_send_raw_transaction(setup_blockchain):
     test_tx_hash = _test_transaction_rpc(transaction.send_raw_transaction, raw_tx)
+    assert isinstance(test_tx_hash, str)
     assert test_tx_hash == tx_hash
 
 @pytest.mark.run(order=8)
 def test_get_pending_cx_receipts(setup_blockchain):
-    _test_transaction_rpc(transaction.get_pending_cx_receipts)
+    pending = _test_transaction_rpc(transaction.get_pending_cx_receipts)
+    assert isinstance(pending, list)
 
 @pytest.mark.run(order=9)
 def test_get_cx_receipt_by_hash(setup_blockchain):
     cx = _test_transaction_rpc(transaction.get_cx_receipt_by_hash, cx_hash)
-    assert cx is not None
+    assert cx
+    assert isinstance(cx, dict)
 
 @pytest.mark.run(order=10)
 def test_resend_cx_receipt(setup_blockchain):
     sent = _test_transaction_rpc(transaction.resend_cx_receipt, cx_hash)
+    assert isinstance(sent, bool)
     assert not sent
 
 @pytest.mark.run(order=11)
 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 is not None
+    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'], 0)
     global stx_block_hash
@@ -106,20 +121,24 @@ 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, test_index)
-    assert stx is not None
+    assert stx
+    assert isinstance(stx, dict)
 
 @pytest.mark.run(order=13)
 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, test_index)
-    assert stx is not None
+    assert stx
+    assert isinstance(stx, dict)
 
 @pytest.mark.run(order=14)
 def test_get_staking_transaction_error_sink(setup_blockchain):
-    _test_transaction_rpc(transaction.get_staking_transaction_error_sink)
+    errors = _test_transaction_rpc(transaction.get_staking_transaction_error_sink)
+    assert isinstance(errors, list)
 
 @pytest.mark.run(order=15)
 def test_send_raw_staking_transaction(setup_blockchain):
     test_stx_hash = _test_transaction_rpc(transaction.send_raw_staking_transaction, raw_stx)
+    assert isinstance(test_stx_hash, str)
     assert test_stx_hash == stx_hash