async def request_response(client: RSocketClient): payload = Payload( b'The quick brown fox', composite(route('single_request'), authenticate_simple('user', '12345'))) await client.request_response(payload)
async def request_last_metadata(client: RxRSocket): payload = Payload(metadata=composite(route('last_metadata_push'), authenticate_simple('user', '12345'))) result = await client.request_response(payload).pipe() assert result.data == b'audit info'
async def test_routed_request_channel_properly_finished(lazy_pipe): router = RequestRouter() def handler_factory(socket): return RoutingRequestHandler(socket, router) def feed(): for x in range(3): yield Payload('Feed Item: {}'.format(x).encode('utf-8')), x == 2 @router.channel('test.path') async def response_stream(): return StreamFromGenerator(feed), DefaultSubscriber() async with lazy_pipe(client_arguments={ 'metadata_encoding': WellKnownMimeTypes.MESSAGE_RSOCKET_COMPOSITE_METADATA }, server_arguments={'handler_factory': handler_factory }) as (server, client): received_messages = await AwaitableRSocket(client).request_channel( Payload(metadata=composite(route('test.path')))) assert len(received_messages) == 3 assert received_messages[0].data == b'Feed Item: 0' assert received_messages[1].data == b'Feed Item: 1' assert received_messages[2].data == b'Feed Item: 2'
async def request_fragmented_stream(client: RxRSocket): payload = Payload( b'The quick brown fox', composite(route('fragmented_stream'), authenticate_simple('user', '12345'))) result = await client.request_stream(payload).pipe(operators.to_list()) print(result)
async def test_authentication_success_on_setup(lazy_pipe): class Handler(BaseRequestHandler): def __init__(self, socket): super().__init__(socket) self._authenticated = False async def on_setup(self, data_encoding: bytes, metadata_encoding: bytes, payload: Payload): composite_metadata = self._parse_composite_metadata( payload.metadata) authentication: AuthenticationSimple = composite_metadata.items[ 0].authentication if authentication.username != b'user' or authentication.password != b'12345': raise Exception('Authentication rejected') self._authenticated = True async def request_response(self, payload: Payload) -> Awaitable[Payload]: if not self._authenticated: raise RSocketApplicationError("Not authenticated") return create_future(Payload(b'response')) async with lazy_pipe(client_arguments={ 'setup_payload': Payload(metadata=composite(authenticate_simple('user', '12345'))) }, server_arguments={'handler_factory': Handler}) as (server, client): result = await client.request_response(Payload(b'request')) assert result.data == b'response'
async def metadata_push(client: RxRSocket, metadata: bytes): await client.metadata_push( composite( route('metadata_push'), authenticate_simple('user', '12345'), metadata_item(metadata, WellKnownMimeTypes.TEXT_PLAIN.value.name))).pipe()
async def test_authentication_helper_bearer(): metadata = composite(authenticate_bearer('token')) composite_metadata = CompositeMetadata() composite_metadata.parse(metadata) assert composite_metadata.items[0].authentication.token == b'token'
async def test_routed_push_metadata(lazy_pipe): router = RequestRouter() received_metadata = None received = asyncio.Event() def handler_factory(socket): return RoutingRequestHandler(socket, router) @router.metadata_push('test.path') async def metadata_push(payload): nonlocal received_metadata received_metadata = payload.metadata received.set() async with lazy_pipe(client_arguments={ 'metadata_encoding': WellKnownMimeTypes.MESSAGE_RSOCKET_COMPOSITE_METADATA }, server_arguments={'handler_factory': handler_factory }) as (server, client): metadata = composite(route('test.path')) await client.metadata_push(metadata) await received.wait() assert received_metadata == metadata
async def test_routed_request_response_properly_finished_accept_payload_and_metadata( lazy_pipe): router = RequestRouter() def handler_factory(socket): return RoutingRequestHandler(socket, router) @router.response('test.path') async def response(payload: Payload, composite_metadata: CompositeMetadata): return create_future( Payload(('Response %s' % payload.data.decode()).encode(), composite_metadata.items[0].tags[0])) async with lazy_pipe(client_arguments={ 'metadata_encoding': WellKnownMimeTypes.MESSAGE_RSOCKET_COMPOSITE_METADATA }, server_arguments={'handler_factory': handler_factory }) as (server, client): result = await client.request_response( Payload(data=b'request', metadata=composite(route('test.path')))) assert result.data == b'Response request' assert result.metadata == b'test.path'
async def request_slow_stream(client: RSocketClient): payload = Payload( b'The quick brown fox', composite(route('slow_stream'), authenticate_simple('user', '12345'))) completion_event = Event() client.request_stream(payload).subscribe( StreamSubscriber(completion_event)) await completion_event.wait()
async def request_stream_invalid_login(client: RSocketClient): payload = Payload( b'The quick brown fox', composite(route('stream'), authenticate_simple('user', 'wrong_password'))) completion_event = Event() client.request_stream(payload).initial_request_n(1).subscribe( StreamSubscriber(completion_event)) await completion_event.wait()
async def request_channel(client: RxRSocket): # channel_completion_event = Event() # requester_completion_event = Event() payload = Payload( b'The quick brown fox', composite(route('channel'), authenticate_simple('user', '12345'))) # publisher = from_rsocket_publisher(sample_publisher(requester_completion_event)) result = await client.request_channel(payload, 5).pipe(operators.to_list())
async def request_stream_invalid_login(client: RxRSocket): payload = Payload( b'The quick brown fox', composite(route('stream'), authenticate_simple('user', 'wrong_password'))) try: await client.request_stream(payload, request_limit=1).pipe() except RuntimeError as exception: assert str(exception) == 'Authentication error'
def test_data_mime_type_composite_metadata(): data = composite(data_mime_type(WellKnownMimeTypes.APPLICATION_JSON)) composite_metadata = CompositeMetadata() composite_metadata.parse(data) assert len(composite_metadata.items) == 1 assert composite_metadata.items[0].data_encoding == b'application/json' assert composite_metadata.serialize() == data
async def test_authentication_failure_on_setup(lazy_pipe): received_error_event = Event() received_error: Optional[tuple] = None class ServerHandler(BaseRequestHandler): def __init__(self, socket): super().__init__(socket) self._authenticated = False async def on_setup(self, data_encoding: bytes, metadata_encoding: bytes, payload: Payload): composite_metadata = self._parse_composite_metadata( payload.metadata) authentication: AuthenticationSimple = composite_metadata.items[ 0].authentication if authentication.username != b'user' or authentication.password != b'12345': raise Exception('Authentication error') self._authenticated = True async def request_response(self, payload: Payload) -> Awaitable[Payload]: if not self._authenticated: raise Exception("Not authenticated") future = asyncio.get_event_loop().create_future() future.set_result(Payload(b'response')) return future class ClientHandler(BaseRequestHandler): async def on_error(self, error_code: ErrorCode, payload: Payload): nonlocal received_error received_error = (error_code, payload) received_error_event.set() async with lazy_pipe(client_arguments={ 'handler_factory': ClientHandler, 'setup_payload': Payload(metadata=composite( authenticate_simple('user', 'wrong_password'))) }, server_arguments={'handler_factory': ServerHandler}) as (server, client): with pytest.raises(RuntimeError): await client.request_response(Payload(b'request')) await received_error_event.wait() assert received_error[0] == ErrorCode.REJECTED_SETUP assert received_error[1] == Payload(b'Authentication error', b'')
def test_data_mime_types_composite_metadata(): data = composite( data_mime_types(WellKnownMimeTypes.APPLICATION_JSON, WellKnownMimeTypes.TEXT_XML)) composite_metadata = CompositeMetadata() composite_metadata.parse(data) assert len(composite_metadata.items) == 1 assert composite_metadata.items[0].data_encodings[0] == b'application/json' assert composite_metadata.items[0].data_encodings[1] == b'text/xml' assert composite_metadata.serialize() == data
async def main(): connection = await asyncio.open_connection('localhost', 7000) setup_payload = Payload(data=str(uuid4()).encode(), metadata=composite( route('shell-client'), authenticate_simple('user', 'pass'))) async with RSocketClient(single_transport_provider( TransportTCP(*connection)), setup_payload=setup_payload, metadata_encoding=WellKnownMimeTypes. MESSAGE_RSOCKET_COMPOSITE_METADATA): await asyncio.sleep(5)
async def request_channel(client: RSocketClient): channel_completion_event = Event() requester_completion_event = Event() payload = Payload( b'The quick brown fox', composite(route('channel'), authenticate_simple('user', '12345'))) publisher = sample_publisher(requester_completion_event) requested = client.request_channel(payload, publisher) requested.initial_request_n(5).subscribe( ChannelSubscriber(channel_completion_event)) await channel_completion_event.wait() await requester_completion_event.wait()
async def test_no_route_in_request(lazy_pipe): router = RequestRouter() def handler_factory(socket): return RoutingRequestHandler(socket, router) async with lazy_pipe(client_arguments={ 'metadata_encoding': WellKnownMimeTypes.MESSAGE_RSOCKET_COMPOSITE_METADATA }, server_arguments={'handler_factory': handler_factory }) as (server, client): with pytest.raises(Exception) as exc_info: await RxRSocket(client).request_channel( Payload( metadata=composite(authenticate_simple('user', 'pass')))) assert str(exc_info.value) == 'No route found in request'
async def test_routed_request_response_properly_finished(lazy_pipe): router = RequestRouter() def handler_factory(socket): return RoutingRequestHandler(socket, router) @router.response('test.path') async def response(): return create_future(Payload(b'result')) async with lazy_pipe(client_arguments={ 'metadata_encoding': WellKnownMimeTypes.MESSAGE_RSOCKET_COMPOSITE_METADATA }, server_arguments={'handler_factory': handler_factory }) as (server, client): result = await client.request_response( Payload(metadata=composite(route('test.path')))) assert result.data == b'result'
async def test_invalid_request_channel(lazy_pipe): router = RequestRouter() def handler_factory(socket): return RoutingRequestHandler(socket, router) @router.channel('test.path') async def request_channel(): raise Exception('error from server') async with lazy_pipe(client_arguments={ 'metadata_encoding': WellKnownMimeTypes.MESSAGE_RSOCKET_COMPOSITE_METADATA }, server_arguments={'handler_factory': handler_factory }) as (server, client): with pytest.raises(Exception) as exc_info: await RxRSocket(client).request_channel( Payload(metadata=composite(route('test.path')))) assert str(exc_info.value) == 'error from server'
def test_metadata_authentication_bearer(): metadata = build_frame( bits(1, 1, 'Well known metadata type'), bits(7, WellKnownMimeTypes.MESSAGE_RSOCKET_AUTHENTICATION.value.id, 'Mime ID'), bits(24, 6, 'Metadata length'), bits(1, 1, 'Well known authentication type'), bits(7, WellKnownAuthenticationTypes.BEARER.value.id, 'Authentication ID'), data_bits(b'12345'), ) composite_metadata = CompositeMetadata() composite_metadata.parse(metadata) assert composite_metadata.items[0].authentication.token == b'12345' assert composite_metadata.serialize() == metadata metadata_from_helper = composite(authenticate_bearer('12345')) assert metadata_from_helper == metadata
async def test_routed_request_response_with_payload_mapper(lazy_pipe): router = RequestRouter(lambda cls, _: json.loads(_.data.decode())) def handler_factory(socket): return RoutingRequestHandler(socket, router) @router.response('test.path') async def response(payload: dict): return create_future(Payload( ('Response %s' % payload['key']).encode())) async with lazy_pipe(client_arguments={ 'metadata_encoding': WellKnownMimeTypes.MESSAGE_RSOCKET_COMPOSITE_METADATA }, server_arguments={'handler_factory': handler_factory }) as (server, client): result = await client.request_response( Payload(data=json.dumps({ 'key': 'value' }).encode(), metadata=composite(route('test.path')))) assert result.data == b'Response value'
async def fire_and_forget(client: RxRSocket, data: bytes): payload = Payload( data, composite(route('no_response'), authenticate_simple('user', '12345'))) await client.fire_and_forget(payload).pipe()