def test_getKnownPeers(self):
db_state = Mock(spec=State)
p2p_factory = Mock(spec=P2PFactory)
p2p_factory.sync_state = SyncState()
p2p_factory.connections = 23
p2p_factory.pos = Mock()
p2p_factory.pos.stake = False
buffered_chain = Mock(spec=BufferedChain)
buffered_chain.height = 0
qrlnode = QRLNode(db_state)
qrlnode.set_p2pfactory(p2p_factory)
qrlnode.set_chain(buffered_chain)
qrlnode._peer_addresses = ['127.0.0.1', '192.168.1.1']
service = PublicAPIService(qrlnode)
response = service.GetKnownPeers(request=qrl_pb2.GetKnownPeersReq,
context=None)
self.assertEqual(2, len(response.known_peers))
self.assertEqual('127.0.0.1', response.known_peers[0].ip)
self.assertEqual('192.168.1.1', response.known_peers[1].ip)
logger.info(response)
def test_getKnownPeers(self):
p2p_factory = Mock(spec=P2PFactory)
p2p_factory.sync_state = SyncState()
p2p_factory.num_connections = 23
p2p_factory.pow = Mock()
chain_manager = Mock(spec=ChainManager)
chain_manager.height = 0
chain_manager.last_block = Block()
qrlnode = QRLNode(mining_address=b'')
qrlnode.set_chain_manager(chain_manager)
qrlnode._p2pfactory = p2p_factory
qrlnode._pow = p2p_factory.pow
qrlnode.peer_manager = Mock()
qrlnode.peer_manager.known_peer_addresses = [
'127.0.0.1', '192.168.1.1'
]
service = PublicAPIService(qrlnode)
response = service.GetKnownPeers(request=qrl_pb2.GetKnownPeersReq,
context=None)
self.assertEqual(2, len(response.known_peers))
self.assertEqual('127.0.0.1', response.known_peers[0].ip)
self.assertEqual('192.168.1.1', response.known_peers[1].ip)
logger.info(response)
def __init__(self, db_state: State, mining_address: bytes):
self.start_time = time.time()
self.db_state = db_state
self._sync_state = SyncState()
self.peer_manager = P2PPeerManager()
self.peer_manager.load_peer_addresses()
self.peer_manager.register(P2PPeerManager.EventType.NO_PEERS,
self.connect_peers)
self.p2pchain_manager = P2PChainManager()
self.tx_manager = P2PTxManagement()
self._chain_manager = None # FIXME: REMOVE. This is temporary
self._p2pfactory = None # FIXME: REMOVE. This is temporary
self._pow = None
self.mining_address = mining_address
banned_peers_filename = os.path.join(config.user.wallet_dir,
config.dev.banned_peers_filename)
self._banned_peers = ExpiringSet(
expiration_time=config.user.ban_minutes * 60,
filename=banned_peers_filename)
reactor.callLater(10, self.monitor_chain_state)
def test_GetAddressFromPK(self):
db_state = Mock(spec=State)
p2p_factory = Mock(spec=P2PFactory)
p2p_factory.sync_state = SyncState()
p2p_factory.connections = 23
p2p_factory.pow = Mock()
chain_manager = Mock(spec=ChainManager)
chain_manager.height = 0
qrlnode = QRLNode(db_state, mining_address=b'')
qrlnode.set_chain_manager(chain_manager)
qrlnode._p2pfactory = p2p_factory
qrlnode._pow = p2p_factory.pow
service = PublicAPIService(qrlnode)
pk = hstr2bin(
'01060057ac9cb6085a8135631dcf018dff46d9c368a0b64d508f512e584199b6800'
'f8cfcb672b931398a023680fe0308ed4b6ec75877d684bc2ccf11703e8369f064e7'
)
request = qrl_pb2.GetAddressFromPKReq(pk=bytes(pk))
response = service.GetAddressFromPK(request=request, context=None)
self.assertEqual(
'010600b56d161c7de8aa741962e3e49b973b7e53456fa47f2443d69f17c632f29c8b1aab7d2491',
bin2hstr(response.address))
def setUp(self):
p2p_factory = Mock(spec=P2PFactory)
p2p_factory.sync_state = SyncState()
p2p_factory.num_connections = 23
p2p_factory.pow = Mock()
b = Block()
self.chain_manager = Mock(spec=ChainManager)
self.chain_manager.height = 0
self.chain_manager.get_last_block = MagicMock(return_value=b)
self.chain_manager.get_block_header_hash_by_number = MagicMock(
return_value=b.headerhash)
self.qrlnode = QRLNode(mining_address=b'')
self.qrlnode.set_chain_manager(self.chain_manager)
self.qrlnode._p2pfactory = p2p_factory
self.qrlnode._pow = p2p_factory.pow
self.block_header_params = {
"dev_config": config.dev,
"blocknumber": 10,
"prev_headerhash": sha256(b'prevblock'),
"prev_timestamp": 1234567890,
"hashedtransactions": sha256(b'tx1'),
"fee_reward": 1,
"seed_height": 0,
"seed_hash": None,
}
self.service = MiningAPIService(self.qrlnode)
def test_GetBlockMiningCompatible(self):
p2p_factory = Mock(spec=P2PFactory)
p2p_factory.sync_state = SyncState()
p2p_factory.num_connections = 23
p2p_factory.pow = Mock()
chain_manager = Mock(spec=ChainManager)
chain_manager.height = 0
chain_manager.get_last_block = MagicMock(return_value=Block())
qrlnode = QRLNode(mining_address=b'')
qrlnode.set_chain_manager(chain_manager)
qrlnode._p2pfactory = p2p_factory
qrlnode._pow = p2p_factory.pow
block_header = BlockHeader.create(blocknumber=10,
prev_headerhash=sha256(b'prevblock'),
prev_timestamp=1234567890,
hashedtransactions=sha256(b'tx1'),
fee_reward=1)
qrlnode.get_blockheader_and_metadata = MagicMock(
return_value=[block_header, BlockMetadata()])
service = MiningAPIService(qrlnode)
req = qrlmining_pb2.GetBlockMiningCompatibleReq(height=10)
answer = service.GetBlockMiningCompatible(request=req, context=None)
self.assertEqual(10, answer.blockheader.block_number)
self.assertEqual(1, answer.blockheader.reward_fee)
def setUp(self):
db_state = Mock(spec=State)
p2p_factory = Mock(spec=P2PFactory)
p2p_factory.sync_state = SyncState()
p2p_factory.connections = 23
p2p_factory.pos = Mock()
p2p_factory.pos.stake = False
buffered_chain = Mock(spec=BufferedChain)
buffered_chain.height = 0
qrlnode = QRLNode(db_state)
qrlnode.set_p2pfactory(p2p_factory)
qrlnode.set_chain(buffered_chain)
qrlnode._peer_addresses = ['127.0.0.1', '192.168.1.1']
self.service = P2PAPIService(qrlnode)
def test_getStats(self):
db_state = Mock(spec=State)
db_state.stake_validators_tracker = StakeValidatorsTracker()
db_state.total_coin_supply = MagicMock(return_value=1000)
p2p_factory = Mock(spec=P2PFactory)
p2p_factory.sync_state = SyncState()
p2p_factory.connections = 23
p2p_factory.pos = Mock()
p2p_factory.pos.stake = False
buffered_chain = Mock(spec=BufferedChain)
buffered_chain.height = 0
buffered_chain._chain = Mock()
buffered_chain._chain.blockchain = []
buffered_chain.get_block = MagicMock(return_value=None)
buffered_chain.state = db_state
qrlnode = QRLNode(db_state)
qrlnode.set_p2pfactory(p2p_factory)
qrlnode.set_chain(buffered_chain)
service = PublicAPIService(qrlnode)
stats = service.GetStats(request=qrl_pb2.GetStatsReq, context=None)
# self.assertEqual(__version__, stats.node_info.version) # FIXME
self.assertEqual(qrl_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(0, stats.stakers_count)
self.assertEqual(0, 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, stats.coins_atstake)
logger.info(stats)
def __init__(self, mining_address: bytes):
self.start_time = ntp.getTime()
self._sync_state = SyncState()
self.peer_manager = P2PPeerManager()
self.peer_manager.load_peer_addresses()
self.p2pchain_manager = P2PChainManager()
self.tx_manager = P2PTxManagement()
self._chain_manager = None # FIXME: REMOVE. This is temporary
self._p2pfactory = None # FIXME: REMOVE. This is temporary
self._pow = None
self.mining_address = mining_address
reactor.callLater(10, self.monitor_chain_state)
def test_getStats(self):
db_state = Mock(spec=State)
db_state.total_coin_supply = MagicMock(return_value=1000)
db_state.get_measurement = MagicMock(return_value=60)
p2p_factory = Mock(spec=P2PFactory)
p2p_factory.sync_state = SyncState()
p2p_factory.connections = 23
p2p_factory.pow = Mock()
chain_manager = Mock(spec=ChainManager)
chain_manager.height = 0
chain_manager.get_last_block = MagicMock(return_value=GenesisBlock())
chain_manager.get_block_by_number = MagicMock(return_value=None)
chain_manager.state = db_state
qrlnode = QRLNode(db_state, mining_address=b'')
qrlnode.set_chain_manager(chain_manager)
qrlnode._p2pfactory = p2p_factory
qrlnode._pow = p2p_factory.pow
service = PublicAPIService(qrlnode)
request = qrl_pb2.GetStatsReq()
stats = service.GetStats(request=request, context=None)
# self.assertEqual(__version__, stats.node_info.version) # FIXME
self.assertEqual(qrl_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(60, 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_GetTokenTxn_Error(self):
p2p_factory = Mock(spec=P2PFactory)
p2p_factory.sync_state = SyncState()
p2p_factory.num_connections = 23
p2p_factory.pow = Mock()
chain_manager = Mock(spec=ChainManager)
chain_manager.height = 0
qrlnode = QRLNode(mining_address=b'')
qrlnode.set_chain_manager(chain_manager)
qrlnode._p2pfactory = p2p_factory
qrlnode._pow = p2p_factory.pow
service = PublicAPIService(qrlnode)
request = qrl_pb2.TokenTxnReq()
context = Mock(spec=ServicerContext)
context.set_code = MagicMock()
service.GetTokenTxn(request=request, context=context)
context.set_code.assert_called_with(StatusCode.INVALID_ARGUMENT)
def test_getNodeState(self):
db_state = Mock(spec=State)
p2p_factory = Mock(spec=P2PFactory)
p2p_factory.sync_state = SyncState()
p2p_factory.connections = 23
p2p_factory.pow = Mock()
chain_manager = Mock(spec=ChainManager)
chain_manager.height = 0
qrlnode = QRLNode(db_state, mining_address=b'')
qrlnode.set_chain_manager(chain_manager)
qrlnode._p2pfactory = p2p_factory
qrlnode._pow = p2p_factory.pow
service = PublicAPIService(qrlnode)
node_state = service.GetNodeState(request=qrl_pb2.GetNodeStateReq, context=None)
# self.assertEqual(__version__, node_state.info.version) # FIXME
self.assertEqual(qrl_pb2.NodeInfo.UNSYNCED, node_state.info.state)
self.assertEqual(23, node_state.info.num_connections)
def test_getNodeState(self):
db_state = Mock(spec=State)
p2p_factory = Mock(spec=P2PFactory)
p2p_factory.sync_state = SyncState()
p2p_factory.connections = 23
p2p_factory.pos = Mock()
p2p_factory.pos.stake = False
buffered_chain = Mock(spec=BufferedChain)
buffered_chain.height = 0
qrlnode = QRLNode(db_state)
qrlnode.set_p2pfactory(p2p_factory)
qrlnode.set_chain(buffered_chain)
service = PublicAPIService(qrlnode)
node_state = service.GetNodeState(request=qrl_pb2.GetNodeStateReq,
context=None)
# self.assertEqual(__version__, node_state.info.version) # FIXME
self.assertEqual(qrl_pb2.NodeInfo.UNSYNCED, node_state.info.state)
self.assertEqual(23, node_state.info.num_connections)