def test_getHeight(self):
with set_xrd_dir('no_data'):
db_state = State()
alice_xmss = get_alice_xmss()
optimized_address_state = OptimizedAddressState.create(address=alice_xmss.address,
nonce=25,
balance=10,
ots_bitfield_used_page=0,
transaction_hash_count=0,
tokens_count=0,
lattice_pk_count=0,
slaves_count=0,
multi_sig_address_count=0)
addresses_state = {optimized_address_state.address: optimized_address_state}
AddressState.put_addresses_state(db_state, addresses_state)
p2p_factory = Mock(spec=P2PFactory)
chain_manager = ChainManager(db_state)
chain_manager._last_block = Mock()
chain_manager._last_block.block_number = 100
xrdnode = xrdNode(mining_address=b'')
xrdnode.set_chain_manager(chain_manager)
xrdnode._p2pfactory = p2p_factory
xrdnode._peer_addresses = ['127.0.0.1', '192.168.1.1']
service = PublicAPIService(xrdnode)
context = Mock(spec=ServicerContext)
request = xrd_pb2.GetHeightReq()
response = service.GetHeight(request=request, context=context)
self.assertEqual(response.height, 100)
def test_getStats(self):
db_state = Mock(spec=State)
db_state.total_coin_supply = 1000
db_state.get_measurement = MagicMock(return_value=60)
db_state.get_block_by_number = MagicMock(return_value=None)
p2p_factory = Mock(spec=P2PFactory)
p2p_factory.sync_state = SyncState()
p2p_factory.num_connections = 23
p2p_factory.pow = Mock()
chain_manager = ChainManager(db_state)
chain_manager._last_block = GenesisBlock()
xrdnode = xrdNode(mining_address=b'')
xrdnode.set_chain_manager(chain_manager)
xrdnode._p2pfactory = p2p_factory
xrdnode._pow = p2p_factory.pow
service = PublicAPIService(xrdnode)
request = xrd_pb2.GetStatsReq()
stats = service.GetStats(request=request, context=None)
# self.assertEqual(__version__, stats.node_info.version) # FIXME
self.assertEqual(xrd_pb2.NodeInfo.UNSYNCED, stats.node_info.state)
self.assertEqual(23, stats.node_info.num_connections)
# self.assertEqual("testnet", stats.node_info.network_id) # FIXME
self.assertEqual(0, stats.epoch)
self.assertEqual(0, stats.uptime_network)
self.assertEqual(65000000000000000, stats.block_last_reward)
self.assertEqual(0, stats.block_time_mean)
self.assertEqual(0, stats.block_time_sd)
self.assertEqual(105000000, stats.coins_total_supply)
self.assertEqual(1000, stats.coins_emitted)
self.assertEqual(0, len(stats.block_timeseries))
def test_getLatestData(self):
with set_xrd_dir('no_data'):
db_state = State()
chain_manager = ChainManager(db_state)
blocks = []
txs = []
alice_xmss = get_alice_xmss()
bob_xmss = get_bob_xmss()
for i in range(0, 4):
for j in range(1, 3):
txs.append(TransferTransaction.create(addrs_to=[bob_xmss.address],
amounts=[i * 100 + j],
message_data=None,
fee=j,
xmss_pk=alice_xmss.pk))
blocks.append(Block.create(dev_config=config.dev,
block_number=i,
prev_headerhash=sha256(b'reveal'),
prev_timestamp=10,
transactions=txs,
miner_address=alice_xmss.address,
seed_height=10,
seed_hash=None))
block = blocks[i]
Block.put_block(db_state,
block,
None)
Block.put_block_number_mapping(db_state,
block.block_number,
xrd_pb2.BlockNumberMapping(headerhash=block.headerhash),
None)
TransactionMetadata.update_tx_metadata(db_state, block, None)
chain_manager._last_block = blocks[-1]
txpool = []
txs = []
for j in range(10, 15):
tx = TransferTransaction.create(addrs_to=[bob_xmss.address],
amounts=[1000 + j],
message_data=None,
fee=j,
xmss_pk=get_alice_xmss().pk)
txpool.append((tx.fee, TransactionInfo(tx, 0)))
txs.append(tx)
p2p_factory = Mock(spec=P2PFactory)
p2p_factory.pow = Mock(spec=POW)
chain_manager.tx_pool = Mock()
chain_manager.tx_pool.transactions = heapq.nlargest(len(txpool), txpool)
chain_manager.tx_pool.transaction_pool = txpool
xrdnode = xrdNode(mining_address=b'')
xrdnode.set_chain_manager(chain_manager)
xrdnode.get_block_from_index = MagicMock(return_value=None)
xrdnode._p2pfactory = p2p_factory
xrdnode._pow = p2p_factory.pow
service = PublicAPIService(xrdnode)
context = Mock(spec=ServicerContext)
request = xrd_pb2.GetLatestDataReq(filter=xrd_pb2.GetLatestDataReq.ALL,
offset=0,
quantity=3)
response = service.GetLatestData(request=request, context=context)
context.set_code.assert_not_called()
context.set_details.assert_not_called()
# Verify blockheaders
self.assertEqual(3, len(response.blockheaders))
self.assertEqual(1, response.blockheaders[0].header.block_number)
self.assertEqual(2, response.blockheaders[1].header.block_number)
self.assertEqual(3, response.blockheaders[2].header.block_number)
# Verify transactions_unconfirmed
self.assertEqual(3, len(response.transactions_unconfirmed))
# TODO: Verify expected order
self.assertEqual(1014, response.transactions_unconfirmed[0].tx.transfer.amounts[0])
self.assertEqual(1013, response.transactions_unconfirmed[1].tx.transfer.amounts[0])
self.assertEqual(1012, response.transactions_unconfirmed[2].tx.transfer.amounts[0])
# Verify transactions
self.assertEqual(3, len(response.transactions))
self.assertEqual(2, response.transactions[0].tx.fee)
self.assertEqual(1, response.transactions[1].tx.fee)
self.assertEqual(2, response.transactions[2].tx.fee)
self.assertEqual(302, response.transactions[0].tx.transfer.amounts[0])
self.assertEqual(301, response.transactions[1].tx.transfer.amounts[0])
self.assertEqual(202, response.transactions[2].tx.transfer.amounts[0])