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 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_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 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 test_valid_authentication_in_routing_handler(lazy_pipe):
router = RequestRouter()
async def authenticate(path: str, authentication: Authentication):
if not isinstance(
authentication,
AuthenticationSimple) or authentication.password != b'pass':
raise Exception('Invalid credentials')
@router.response('test.path')
async def response():
return create_future(Payload(b'result'))
def handler_factory(socket):
return RoutingRequestHandler(socket,
router,
authentication_verifier=authenticate)
async with lazy_pipe(client_arguments={
'metadata_encoding':
WellKnownMimeTypes.MESSAGE_RSOCKET_COMPOSITE_METADATA
},
server_arguments={'handler_factory': handler_factory
}) as (server, client):
result = await RxRSocket(client).request_response(
Payload(metadata=composite(route('test.path'),
authenticate_simple('user', 'pass'))))
assert result.data == b'result'
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 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_invalid_authentication_in_routing_handler(lazy_pipe):
router = RequestRouter()
async def authenticate(path: str, authentication: Authentication):
if not isinstance(
authentication,
AuthenticationSimple) or authentication.password != b'pass':
raise Exception('Invalid credentials')
@router.channel('test.path')
async def request_channel():
raise Exception('error from server')
def handler_factory(socket):
return RoutingRequestHandler(socket,
router,
authentication_verifier=authenticate)
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'),
authenticate_simple('user', 'wrong_password'))))
assert str(exc_info.value) == 'Invalid credentials'
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'
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_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'
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()
