def test_matrix_message_sync(
local_matrix_servers,
private_rooms,
retry_interval,
retries_before_backoff,
):
transport0 = MatrixTransport({
'global_rooms': ['discovery'],
'retries_before_backoff': retries_before_backoff,
'retry_interval': retry_interval,
'server': local_matrix_servers[0],
'server_name': local_matrix_servers[0].netloc,
'available_servers': [],
'private_rooms': private_rooms,
})
transport1 = MatrixTransport({
'global_rooms': ['discovery'],
'retries_before_backoff': retries_before_backoff,
'retry_interval': retry_interval,
'server': local_matrix_servers[0],
'server_name': local_matrix_servers[0].netloc,
'available_servers': [],
'private_rooms': private_rooms,
})
latest_auth_data = None
received_messages = set()
message_handler = MessageHandler(received_messages)
raiden_service0 = MockRaidenService(message_handler)
raiden_service1 = MockRaidenService(message_handler)
raiden_service1.handle_and_track_state_change = MagicMock()
transport0.start(
raiden_service0,
message_handler,
None,
)
transport1.start(
raiden_service1,
message_handler,
None,
)
gevent.sleep(1)
latest_auth_data = f'{transport1._user_id}/{transport1._client.api.token}'
update_transport_auth_data = ActionUpdateTransportAuthData(
latest_auth_data)
raiden_service1.handle_and_track_state_change.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,
channel_identifier=1,
)
for i in range(5):
message = Processed(message_identifier=i)
transport0._raiden_service.sign(message)
transport0.send_async(
queue_identifier,
message,
)
gevent.sleep(2)
assert len(received_messages) == 10
for i in range(5):
assert any(
getattr(m, 'message_identifier', -1) == i
for m in received_messages)
transport1.stop()
assert latest_auth_data
# Send more messages while the other end is offline
for i in range(10, 15):
message = Processed(message_identifier=i)
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,
)
gevent.sleep(2)
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)
transport0.stop()
transport1.stop()
transport0.get()
transport1.get()
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_change = MagicMock()
transport0.start(raiden_service0, message_handler, None)
transport1.start(raiden_service1, message_handler, None)
gevent.sleep(1)
latest_auth_data = f"{transport1._user_id}/{transport1._client.api.token}"
update_transport_auth_data = ActionUpdateTransportAuthData(
latest_auth_data)
raiden_service1.handle_and_track_state_change.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, channel_identifier=1)
for i in range(5):
message = Processed(message_identifier=i)
transport0._raiden_service.sign(message)
transport0.send_async(queue_identifier, message)
with Timeout(40):
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)
transport1.stop()
assert latest_auth_data
# Send more messages while the other end is offline
for i in range(10, 15):
message = Processed(message_identifier=i)
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)
gevent.sleep(2)
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)
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)
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(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)
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, [], latest_auth_data)
transport1.start_health_check(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)