def test_matrix_message_sync( local_matrix_servers, private_rooms, retry_interval, retries_before_backoff, ): transport0 = MatrixTransport({ 'discovery_room': '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({ 'discovery_room': '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_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_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(i) message.sign(transport0._raiden_service.private_key) 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(i) message.sign(transport0._raiden_service.private_key) 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( skip_if_not_matrix, local_matrix_server, private_rooms, retry_interval, retries_before_backoff, ): transport0 = MatrixTransport({ 'discovery_room': 'discovery', 'retries_before_backoff': retries_before_backoff, 'retry_interval': retry_interval, 'server': local_matrix_server, 'server_name': 'matrix.local.raiden', 'available_servers': [], 'private_rooms': private_rooms, }) transport1 = MatrixTransport({ 'discovery_room': 'discovery', 'retries_before_backoff': retries_before_backoff, 'retry_interval': retry_interval, 'server': local_matrix_server, 'server_name': 'matrix.local.raiden', 'available_servers': [], 'private_rooms': private_rooms, }) latest_sync_token = None received_messages = set() def hook(sync_token): nonlocal latest_sync_token latest_sync_token = sync_token class MessageHandler: def on_message(self, _, message): nonlocal received_messages received_messages.add(message) transport0._client.set_post_sync_hook(hook) message_handler = MessageHandler() raiden_service0 = MockRaidenService(message_handler) raiden_service1 = MockRaidenService(message_handler) raiden_service1.handle_state_change = MagicMock() transport0.start( raiden_service0, message_handler, None, ) transport1.start( raiden_service1, message_handler, None, ) 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(i) message.sign(transport0._raiden_service.private_key) transport0.send_async( queue_identifier, message, ) gevent.sleep(2) latest_sync_token = f'{transport1._user_id}/{latest_sync_token}' update_transport_sync_token = ActionUpdateTransportSyncToken(latest_sync_token) raiden_service1.handle_state_change.assert_called_with(update_transport_sync_token) 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_sync_token # Send more messages while the other end is offline for i in range(10, 15): message = Processed(i) message.sign(transport0._raiden_service.private_key) transport0.send_async( queue_identifier, message, ) # Should fetch the 5 messages sent while transport1 was offline transport1.start( transport1._raiden_service, message_handler, latest_sync_token, ) 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()