def test_that_exceeding_maximum_frame_length_should_treat_exceeded_frame_as_invalid( self, unused_tcp_port): first_middleman_message = GolemMessageFrame(Ping(), self.request_id) first_raw_message = append_frame_separator( escape_encode_raw_message( first_middleman_message.serialize( private_key=CONCENT_PRIVATE_KEY))) second_middleman_message = AuthenticationChallengeFrame( payload=b'', request_id=100, ) second_raw_message = append_frame_separator( escape_encode_raw_message( second_middleman_message.serialize( private_key=CONCENT_PRIVATE_KEY))) assert len(first_raw_message) > len(second_raw_message) + 10 with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as server_socket: server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True) with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as client_socket: client_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True) server_socket.bind(('127.0.0.1', unused_tcp_port)) server_socket.listen(1) client_socket.connect(('127.0.0.1', unused_tcp_port)) (connection, _address) = server_socket.accept() client_socket.send(first_raw_message) client_socket.send(second_raw_message) with mock.patch( 'middleman_protocol.stream.MAXIMUM_FRAME_LENGTH', len(first_raw_message) - 10): raw_message_received = next( unescape_stream(connection=connection)) deserialized_message = AbstractFrame.deserialize( raw_message=raw_message_received, public_key=CONCENT_PUBLIC_KEY, ) assertpy.assert_that(deserialized_message.request_id).is_equal_to(100)
async def test_that_received_item_received_via_response_queue_is_sent_to_concent(self, event_loop): with override_settings( CONCENT_PRIVATE_KEY=CONCENT_PRIVATE_KEY, CONCENT_PUBLIC_KEY=CONCENT_PUBLIC_KEY, SIGNING_SERVICE_PUBLIC_KEY=SIGNING_SERVICE_PUBLIC_KEY ): connection_id = 11 concent_request_id = 77 response_queue = Queue(loop=event_loop) golem_message = Ping() response_queue_item = ResponseQueueItem(golem_message, concent_request_id, FROZEN_TIMESTAMP) expected_data = append_frame_separator( escape_encode_raw_message( GolemMessageFrame(golem_message, concent_request_id).serialize(settings.CONCENT_PRIVATE_KEY) ) ) mocked_writer = prepare_mocked_writer() await response_queue.put(response_queue_item) consumer_task = event_loop.create_task( response_consumer( response_queue, mocked_writer, connection_id ) ) await response_queue.join() consumer_task.cancel() mocked_writer.write.assert_called_once_with(expected_data) mocked_writer.drain.mock.assert_called_once_with()
async def test_that_when_connection_exists_item_from_the_queue_is_sent_via_writer(self, event_loop): with patch("middleman.asynchronous_operations.logger") as mocked_logger: with override_settings( CONCENT_PRIVATE_KEY=CONCENT_PRIVATE_KEY, CONCENT_PUBLIC_KEY=CONCENT_PUBLIC_KEY, ): expected_data = append_frame_separator( escape_encode_raw_message( GolemMessageFrame(self.golem_message, self.signing_service_request_id).serialize(CONCENT_PRIVATE_KEY) ) ) await self.queue.put(self.request_queue_item) consumer_task = event_loop.create_task( request_consumer( self.queue, self.queue_pool, self.message_tracker, self.mocked_writer ) ) await self.queue.join() consumer_task.cancel() assert_that(self.message_tracker[self.signing_service_request_id]).is_equal_to( MessageTrackerItem( self.request_id, self.connection_id, self.golem_message, FROZEN_TIMESTAMP ) ) mocked_logger.debug.assert_not_called() self.mocked_writer.write.assert_called_once_with(expected_data) self.mocked_writer.drain.mock.assert_called_once_with()
def test_that_receiving_a_series_of_messages_should_be_handled_correctly( self, unused_tcp_port): payload = Ping() middleman_message = GolemMessageFrame(payload, self.request_id) raw_message = escape_encode_raw_message( middleman_message.serialize(private_key=CONCENT_PRIVATE_KEY)) raw_message_with_separator = append_frame_separator(raw_message) with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as server_socket: server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True) with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as client_socket: client_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True) server_socket.bind(('127.0.0.1', unused_tcp_port)) server_socket.listen(1) client_socket.connect(('127.0.0.1', unused_tcp_port)) (connection, _address) = server_socket.accept() for _i in range(10): client_socket.send(raw_message_with_separator) split_stream_generator = split_stream(connection=connection) for _i in range(10): raw_message_received = next(split_stream_generator) assertpy.assert_that(raw_message).is_equal_to( raw_message_received)
def test_that_receiving_wrongly_encoded_message_should_return_none( self, unused_tcp_port): middleman_message = GolemMessageFrame(Ping(), self.request_id) raw_message = middleman_message.serialize( private_key=CONCENT_PRIVATE_KEY, ) raw_message_encoded = escape_encode_raw_message(raw_message) raw_message_encoded = raw_message_encoded + ESCAPE_CHARACTER + b'\xff' raw_message_encoded = append_frame_separator(raw_message_encoded) with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as server_socket: server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True) with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as client_socket: client_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True) server_socket.bind(('127.0.0.1', unused_tcp_port)) server_socket.listen(1) client_socket.connect(('127.0.0.1', unused_tcp_port)) (connection, _address) = server_socket.accept() client_socket.send(raw_message_encoded) raw_message_received = next( unescape_stream(connection=connection)) assertpy.assert_that(raw_message_received).is_none()
def test_that_remove_frame_separator_should_raise_exception_if_separator_is_not_at_the_end( self): raw_with_separator = append_frame_separator(b'12345') + b'1' assert FRAME_SEPARATOR in raw_with_separator with self.assertRaises(AssertionError): remove_frame_separator(raw_with_separator)
def _get_mocked_reader(message, request_id, sign_as, **kwargs): protocol_message = create_middleman_protocol_message(PayloadType.GOLEM_MESSAGE, message, request_id) data_to_send = append_frame_separator( escape_encode_raw_message( protocol_message.serialize(sign_as) ) ) mocked_reader = prepare_mocked_reader(data_to_send, **kwargs) return mocked_reader
def test_that_remove_frame_separator_should_remove_frame_separator_from_given_bytes( self): raw_with_separator = append_frame_separator(b'12345') assert FRAME_SEPARATOR in raw_with_separator raw = remove_frame_separator(raw_with_separator) self.assertNotIn(FRAME_SEPARATOR, raw)
def test_that_append_frame_separator_should_add_frame_separator_to_given_bytes( self): raw = b'12345' assert FRAME_SEPARATOR not in raw raw_with_separator = append_frame_separator(raw) self.assertIn(FRAME_SEPARATOR, raw_with_separator)
def test_that_remove_frame_separator_should_remove_frame_separator_from_given_bytes_only_at_the_end( self): raw_with_separator = FRAME_SEPARATOR + append_frame_separator(b'12345') assert FRAME_SEPARATOR in raw_with_separator raw = remove_frame_separator(raw_with_separator) self.assertTrue(raw.startswith(FRAME_SEPARATOR)) self.assertFalse(raw.endswith(FRAME_SEPARATOR))
def test_that_sent_data_is_escaped_and_contains_frame_separator(event_loop): frame = GolemMessageFrame(Ping(), 777) expected_data = append_frame_separator( escape_encode_raw_message(frame.serialize(CONCENT_PRIVATE_KEY))) mocked_writer = prepare_mocked_writer() task = _run_test_in_event_loop(event_loop, send_over_stream_async, frame, mocked_writer, CONCENT_PRIVATE_KEY) assert_that(task.done()).is_true() mocked_writer.write.assert_called_once_with(expected_data) mocked_writer.drain.mock.assert_called_once_with()
def test_that_receiving_encoded_message_should_decode_on_the_fly( self, unused_tcp_port): middleman_message = GolemMessageFrame(Ping(), self.request_id) raw_message = append_frame_separator( middleman_message.serialize(private_key=CONCENT_PRIVATE_KEY)) raw_message = raw_message[:10] + ESCAPE_CHARACTER + raw_message[ len(ESCAPE_CHARACTER) + 10:] raw_message_encoded = escape_encode_raw_message(raw_message) assert FRAME_SEPARATOR not in raw_message_encoded raw_message_encoded = append_frame_separator(raw_message_encoded) with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as server_socket: server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True) with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as client_socket: client_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True) server_socket.bind(('127.0.0.1', unused_tcp_port)) server_socket.listen(1) client_socket.connect(('127.0.0.1', unused_tcp_port)) (connection, _address) = server_socket.accept() client_socket.send(raw_message_encoded) raw_message_received = next( unescape_stream(connection=connection)) assertpy_bytes_starts_with(raw_message, raw_message_received) assertpy.assert_that( len(raw_message_received)).is_greater_than_or_equal_to( FRAME_PAYLOAD_STARTING_BYTE)
def setUp(self, unused_tcp_port_factory, event_loop): golem_message_frame = GolemMessageFrame( Ping(), 777).serialize(CONCENT_PRIVATE_KEY) self.patcher = mock.patch("middleman.middleman_server.crash_logger") self.crash_logger_mock = self.patcher.start() self.internal_port, self.external_port = unused_tcp_port_factory( ), unused_tcp_port_factory() self.data_to_send = append_frame_separator( escape_encode_raw_message(golem_message_frame)) self.timeout = 0.2 self.short_delay = 0.1 self.middleman = MiddleMan(internal_port=self.internal_port, external_port=self.external_port, loop=event_loop) yield self.internal_port, self.external_port self.patcher.stop()
def test_heartbeat_producer_sends_heartbeat_in_time_intervals(event_loop): with override_settings( CONCENT_PRIVATE_KEY=CONCENT_PRIVATE_KEY ): mocked_writer = prepare_mocked_writer() expected_data = append_frame_separator( escape_encode_raw_message( HeartbeatFrame(None, HEARTBEAT_REQUEST_ID).serialize(CONCENT_PRIVATE_KEY) ) ) heartbeat_producer_task = event_loop.create_task( heartbeat_producer( mocked_writer, ) ) with patch( "middleman.asynchronous_operations.sleep", new=async_stream_actor_mock(side_effect=lambda _: heartbeat_producer_task.cancel()) ) as sleep_mock: with suppress(CancelledError): event_loop.run_until_complete(heartbeat_producer_task) mocked_writer.write.assert_called_with(expected_data) mocked_writer.drain.mock.assert_called() sleep_mock.mock.assert_called_with(HEARTBEAT_INTERVAL)
async def send_over_stream_async(frame: AbstractFrame, writer: asyncio.StreamWriter, private_key: bytes) -> None: data = frame.serialize(private_key) writer.write(append_frame_separator(escape_encode_raw_message(data))) await writer.drain()
def _prepare_mocked_reader(frame: AbstractFrame, private_key: bytes = SIGNING_SERVICE_PRIVATE_KEY): serialized = frame.serialize(private_key) data_to_send = append_frame_separator(escape_encode_raw_message(serialized)) return prepare_mocked_reader(data_to_send)