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)