def test_fallback_check_error(self):
"""
test reactor.check_headers method
interface didn't returned any best header. will try again in
"""
header_timestamp = int(
time.time()) - self.sut.new_headers_fallback_poll_interval - 1
loc_header = {
"block_height": 1,
"block_hash": "ff" * 32,
"timestamp": header_timestamp
}
self.interface.get_header.side_effect = [exceptions.NoPeersException]
self.sut.synced = True
self.sut.set_last_processed_header(loc_header)
self.loop.run_until_complete(self.sut.check_headers())
self.assertFalse(self.sut.lock.locked())
Mock.assert_called_once_with(self.delay_task_runner,
coro_call('check_headers'), 30)
Mock.assert_called_with(self.interface.get_header,
2,
fail_silent_out_of_range=True,
get_peer=True)
Mock.assert_called_once_with(self.electrod_loop.create_task,
self.delay_task_runner())
self.assertEqual(1, len(self.interface.method_calls))
self.assertEqual(1, len(self.electrod_loop.method_calls))
self.assertEqual(0, len(self.repo.method_calls))
def test_check_new_header_same_header(self):
"""
test on fallback method check_headers
no new header received
"""
header_timestamp = int(time.time()) - 100
loc_header = net_header = {
"block_height": 1,
"block_hash": "ff" * 32,
"timestamp": header_timestamp - 700,
'header_bytes': b'',
'prev_block_hash': '00' * 32
}
peer = Mock(server_info='mock_peer')
self.interface.get_header.side_effect = [
async_coro((peer, net_header))
]
self.sut.synced = True
self.sut.set_last_processed_header(loc_header)
self.assertFalse(self.sut.lock.locked())
self.loop.run_until_complete(self.sut.check_headers())
Mock.assert_called_once_with(self.delay_task_runner,
coro_call('check_headers'),
in_range(655, 660))
Mock.assert_has_calls(self.interface.get_header,
calls=[
call(2,
fail_silent_out_of_range=True,
get_peer=True),
],
any_order=True)
self.assertEqual(1, len(self.interface.method_calls))
self.assertEqual(1, len(self.electrod_loop.method_calls))
self.assertEqual(0, len(self.repo.method_calls))
def test_error_fetching_new_network_best_header(self):
"""
test reactor.check_headers method
interface can't find, due race conditions, peers to fetch the headers
NoPeersException is raised
"""
header_timestamp = int(
time.time()) - self.sut.new_headers_fallback_poll_interval - 1
loc_header = {
"block_height": 1,
"block_hash": "ff" * 32,
"timestamp": header_timestamp
}
self.interface.get_header.side_effect = exceptions.NoPeersException
self.sut.synced = True
self.sut.set_last_processed_header(loc_header)
self.loop.run_until_complete(self.sut.check_headers())
self.assertFalse(self.sut.lock.locked())
Mock.assert_called_once_with(self.delay_task_runner,
coro_call('check_headers'), 30)
Mock.assert_called_with(self.interface.get_header,
2,
fail_silent_out_of_range=True,
get_peer=True)
Mock.assert_called_once_with(self.electrod_loop.create_task,
self.delay_task_runner())
self.assertEqual(1, len(self.interface.method_calls))
self.assertEqual(1, len(self.electrod_loop.method_calls))
self.assertEqual(0, len(self.repo.method_calls))
def test_subscribe_error(self):
self.sut.loop = self.electrod_loop
self.delayer.return_value = 'delayer'
self.client.subscribe.side_effect = ConnectionError
self.loop.run_until_complete(self.sut.subscribe(
'cafe', 'babe', 'c0ca'))
Mock.assert_called_with(self.electrod_loop.create_task, 'delayer')
Mock.assert_called_with(self.delayer, coro_call('on_error'))
def test_rpc_call_error(self):
self.delayer.return_value = 'delayed'
self.client.RPC.return_value = ConnectionError
res = self.loop.run_until_complete(
self.sut.rpc_call('method', ('cafe', 'babe')))
self.assertEqual(res, None)
Mock.assert_called_once_with(self.electrod_loop.create_task, 'delayed')
Mock.assert_called_once_with(self.delayer, coro_call('on_error'))
def test_connect_ok(self):
async def parallel():
await asyncio.sleep(3)
for peer in self.peers:
self.sut.add_peer(peer)
await asyncio.sleep(5)
self.sut._keepalive = False
self.online_checker.side_effect = [async_coro(False), async_coro(True)]
self.loop.run_until_complete(
asyncio.gather(parallel(), self.sut.connect()))
Mock.assert_has_calls(self.loopmock.create_task,
calls=[
call(coro_call('_connect_peer')),
call(coro_call('_connect_peer'))
])
def test_locked_get_header_fallback_task(self):
self.sut.synced = True
self.loop.run_until_complete(self.sut.lock.acquire())
self.loop.run_until_complete(self.sut.check_headers())
self.sut.lock.release()
Mock.assert_called_once_with(self.delay_task_runner,
coro_call('check_headers'),
in_range(29, 30))
def test_check_headers_new_header(self):
"""
test on fallback method check_headers
new header received
"""
header_timestamp = int(time.time()) - 100
loc_header = {
"block_height": 1,
"block_hash": "ff" * 32,
"timestamp": header_timestamp - 700,
'header_bytes': b'',
'prev_block_hash': '00' * 32
}
net_header = {
"block_height": 2,
"block_hash": "aa" * 32,
"timestamp": header_timestamp,
'header_bytes': b'',
'prev_block_hash': 'ff' * 32
}
peer = Mock()
self.interface.get_header.side_effect = [
async_coro((peer, net_header))
]
self.sut.synced = True
self.sut.set_last_processed_header(loc_header)
self.assertFalse(self.sut.lock.locked())
peer = Mock(server_info='mock_peer')
peer.close.return_value = True
self.repo.get_best_header.return_value = loc_header
self.repo.save_header.side_effect = lambda a, b, c, d: True
self.loop.run_until_complete(self.sut.check_headers())
Mock.assert_called_once_with(self.delay_task_runner,
coro_call('check_headers'), 30)
self.assertEqual(1, len(self.interface.method_calls))
self.assertEqual(2, len(self.electrod_loop.method_calls))
self.assertEqual(0, len(self.repo.method_calls))
self.assertTrue(self.sut.synced)
def test_last_header_received_less_than_min_polling_interval(self):
"""
test reactor.check_headers method
last header is saved less than polling interval value (default: 660)
"""
header_timestamp = int(time.time()) - 100
loc_header = {
"block_height": 1,
"block_hash": "ff" * 32,
"timestamp": header_timestamp
}
self.sut.synced = True
self.sut.set_last_processed_header(loc_header)
self.loop.run_until_complete(self.sut.check_headers())
self.assertFalse(self.sut.lock.locked())
Mock.assert_called_once_with(self.delay_task_runner,
coro_call('check_headers'),
in_range(559, 560))
self.assertEqual(0, len(self.interface.method_calls))
self.assertEqual(1, len(self.electrod_loop.method_calls))
self.assertEqual(0, len(self.repo.method_calls))
def test_connectionpool_offline(self):
self.interface.is_pool_online = False
self.loop.run_until_complete(self.sut.check_headers())
Mock.assert_called_with(self.delay_task_runner,
coro_call('check_headers'),
self.sut.new_headers_fallback_poll_interval)
def test_not_synced_yet_fallback_task(self):
self.sut.synced = False
self.loop.run_until_complete(self.sut.check_headers())
Mock.assert_called_once_with(self.delay_task_runner,
coro_call('check_headers'),
in_range(29, 30))