def test_matrix_message_sync(matrix_transports):
transport0, transport1 = matrix_transports
transport0_messages = set()
transport1_messages = set()
transport0_message_handler = MessageHandler(transport0_messages)
transport1_message_handler = MessageHandler(transport1_messages)
raiden_service0 = MockRaidenService(transport0_message_handler)
raiden_service1 = MockRaidenService(transport1_message_handler)
raiden_service1.handle_and_track_state_changes = MagicMock()
transport0.start(raiden_service0, [], None)
transport1.start(raiden_service1, [], None)
transport0.immediate_health_check_for(transport1._raiden_service.address)
transport1.immediate_health_check_for(transport0._raiden_service.address)
queue_identifier = QueueIdentifier(
recipient=transport1._raiden_service.address,
canonical_identifier=factories.UNIT_CANONICAL_ID,
)
raiden0_queues = views.get_all_messagequeues(views.state_from_raiden(raiden_service0))
raiden0_queues[queue_identifier] = []
for i in range(5):
message = Processed(message_identifier=i, signature=EMPTY_SIGNATURE)
raiden0_queues[queue_identifier].append(message)
transport0._raiden_service.sign(message)
transport0.send_async([MessagesQueue(queue_identifier, [message])])
with Timeout(TIMEOUT_MESSAGE_RECEIVE):
while not len(transport0_messages) == 5:
gevent.sleep(0.1)
while not len(transport1_messages) == 5:
gevent.sleep(0.1)
# transport1 receives the `Processed` messages sent by transport0
for i in range(5):
assert any(m.message_identifier == i for m in transport1_messages)
# transport0 answers with a `Delivered` for each `Processed`
for i in range(5):
assert any(m.delivered_message_identifier == i for m in transport0_messages)
# Clear out queue
raiden0_queues[queue_identifier] = []
transport1.stop()
wait_for_peer_unreachable(transport0, transport1._raiden_service.address)
# Send more messages while the other end is offline
for i in range(10, 15):
message = Processed(message_identifier=i, signature=EMPTY_SIGNATURE)
raiden0_queues[queue_identifier].append(message)
transport0._raiden_service.sign(message)
transport0.send_async([MessagesQueue(queue_identifier, [message])])
# Should fetch the 5 messages sent while transport1 was offline
transport1.start(transport1._raiden_service, [], None)
transport1.immediate_health_check_for(transport0._raiden_service.address)
with gevent.Timeout(TIMEOUT_MESSAGE_RECEIVE):
while len(transport1_messages) != 10:
gevent.sleep(0.1)
while len(transport0_messages) != 10:
gevent.sleep(0.1)
# transport1 receives the 5 new `Processed` messages sent by transport0
for i in range(10, 15):
assert any(m.message_identifier == i for m in transport1_messages)
# transport0 answers with a `Delivered` for each one of the new `Processed`
for i in range(10, 15):
assert any(m.delivered_message_identifier == i for m in transport0_messages)
def test_matrix_message_sync(matrix_transports):
transport0, transport1 = matrix_transports
received_messages = set()
message_handler = MessageHandler(received_messages)
raiden_service0 = MockRaidenService(message_handler)
raiden_service1 = MockRaidenService(message_handler)
raiden_service1.handle_and_track_state_changes = MagicMock()
transport0.start(raiden_service0, message_handler, None)
transport1.start(raiden_service1, message_handler, None)
latest_auth_data = f"{transport1._user_id}/{transport1._client.api.token}"
update_transport_auth_data = ActionUpdateTransportAuthData(
latest_auth_data)
with gevent.Timeout(2):
wait_assert(
raiden_service1.handle_and_track_state_changes.assert_called_with,
[update_transport_auth_data],
)
transport0.start_health_check(transport1._raiden_service.address)
transport1.start_health_check(transport0._raiden_service.address)
queue_identifier = QueueIdentifier(
recipient=transport1._raiden_service.address,
canonical_identifier=factories.UNIT_CANONICAL_ID,
)
raiden0_queues = views.get_all_messagequeues(
views.state_from_raiden(raiden_service0))
raiden0_queues[queue_identifier] = []
for i in range(5):
message = Processed(message_identifier=i, signature=EMPTY_SIGNATURE)
raiden0_queues[queue_identifier].append(message)
transport0._raiden_service.sign(message)
transport0.send_async(queue_identifier, message)
with Timeout(TIMEOUT_MESSAGE_RECEIVE):
while not len(received_messages) == 10:
gevent.sleep(0.1)
assert len(received_messages) == 10
for i in range(5):
assert any(
getattr(m, "message_identifier", -1) == i
for m in received_messages)
# Clear out queue
raiden0_queues[queue_identifier] = []
transport1.stop()
wait_for_peer_unreachable(transport0, transport1._raiden_service.address)
assert latest_auth_data
# Send more messages while the other end is offline
for i in range(10, 15):
message = Processed(message_identifier=i, signature=EMPTY_SIGNATURE)
raiden0_queues[queue_identifier].append(message)
transport0._raiden_service.sign(message)
transport0.send_async(queue_identifier, message)
# Should fetch the 5 messages sent while transport1 was offline
transport1.start(transport1._raiden_service, message_handler,
latest_auth_data)
transport1.start_health_check(transport0._raiden_service.address)
with gevent.Timeout(TIMEOUT_MESSAGE_RECEIVE):
while len(set(received_messages)) != 20:
gevent.sleep(0.1)
assert len(set(received_messages)) == 20
for i in range(10, 15):
assert any(
getattr(m, "message_identifier", -1) == i
for m in received_messages)
