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()
