async def test_send_trailing_metadata_on_closed_stream(loop):
client_h2c, server_h2c = create_connections()
to_client_transport = TransportStub(client_h2c)
to_server_transport = TransportStub(server_h2c)
client_conn = Connection(client_h2c, to_server_transport, loop=loop)
server_conn = Connection(server_h2c, to_client_transport, loop=loop)
server_proc = EventsProcessor(DummyHandler(), server_conn)
client_proc = EventsProcessor(DummyHandler(), client_conn)
client_h2_stream = client_conn.create_stream()
await client_h2_stream.send_request(create_headers(),
_processor=client_proc)
request = DummyRequest(value='ping')
await send_message(client_h2_stream,
ProtoCodec(),
request,
DummyRequest,
end=True)
to_server_transport.process(server_proc)
server_h2_stream = server_proc.handler.stream
request_metadata = decode_metadata(server_proc.handler.headers)
send_trailing_metadata_done = False
async with mk_stream(server_h2_stream, request_metadata) as server_stream:
await server_stream.send_trailing_metadata(status=Status.UNKNOWN)
send_trailing_metadata_done = True
assert send_trailing_metadata_done
async def test_exit_and_connection_was_closed(loop):
client_h2c, server_h2c = create_connections()
to_client_transport = TransportStub(client_h2c)
to_server_transport = TransportStub(server_h2c)
client_conn = Connection(client_h2c, to_server_transport, loop=loop)
server_conn = Connection(server_h2c, to_client_transport, loop=loop)
server_proc = EventsProcessor(DummyHandler(), server_conn)
client_proc = EventsProcessor(DummyHandler(), client_conn)
client_h2_stream = client_conn.create_stream()
await client_h2_stream.send_request(create_headers(),
_processor=client_proc)
request = DummyRequest(value='ping')
await send_message(client_h2_stream,
ProtoCodec(),
request,
DummyRequest,
end=True)
to_server_transport.process(server_proc)
server_h2_stream = server_proc.handler.stream
request_metadata = decode_metadata(server_proc.handler.headers)
async with mk_stream(server_h2_stream, request_metadata) as server_stream:
await server_stream.recv_message()
client_h2c.close_connection()
to_server_transport.process(server_proc)
raise ServerError() # should be suppressed
async def test_exit_and_connection_was_broken(loop):
client_h2c, server_h2c = create_connections()
to_client_transport = TransportStub(client_h2c)
to_server_transport = TransportStub(server_h2c)
client_conn = Connection(client_h2c, to_server_transport, loop=loop)
server_conn = Connection(server_h2c, to_client_transport, loop=loop)
server_proc = EventsProcessor(DummyHandler(), server_conn)
client_proc = EventsProcessor(DummyHandler(), client_conn)
client_h2_stream = client_conn.create_stream()
await client_h2_stream.send_request(create_headers(),
_processor=client_proc)
request = DummyRequest(value='ping')
await send_message(client_h2_stream,
ProtoCodec(),
request,
DummyRequest,
end=True)
to_server_transport.process(server_proc)
server_h2_stream = server_proc.handler.stream
request_metadata = decode_metadata(server_proc.handler.headers)
with pytest.raises(WriteError):
async with mk_stream(server_h2_stream,
request_metadata) as server_stream:
server_stream.metadata = request_metadata
await server_stream.recv_message()
# simulate broken connection
to_client_transport.__raise_on_write__(WriteError)
async def test_send_trailing_metadata_on_closed_stream(loop):
client_h2c, server_h2c = create_connections()
to_client_transport = TransportStub(client_h2c)
to_server_transport = TransportStub(server_h2c)
client_conn = Connection(client_h2c, to_server_transport, loop=loop)
server_conn = Connection(server_h2c, to_client_transport, loop=loop)
server_proc = EventsProcessor(DummyHandler(), server_conn)
client_proc = EventsProcessor(DummyHandler(), client_conn)
request = Request(method='POST', scheme='http', path='/',
content_type='application/grpc+proto',
authority='test.com')
client_h2_stream = client_conn.create_stream()
await client_h2_stream.send_request(request.to_headers(),
_processor=client_proc)
request = DummyRequest(value='ping')
await send_message(client_h2_stream, ProtoCodec(), request, DummyRequest,
end=True)
to_server_transport.process(server_proc)
server_h2_stream = server_proc.handler.stream
request_metadata = decode_metadata(server_proc.handler.headers)
send_trailing_metadata_done = False
async with Stream(server_h2_stream, Cardinality.UNARY_UNARY, ProtoCodec(),
DummyRequest, DummyReply,
metadata=request_metadata) as server_stream:
await server_stream.send_trailing_metadata(status=Status.UNKNOWN)
send_trailing_metadata_done = True
assert send_trailing_metadata_done
async def test_exit_and_connection_was_broken(loop):
client_h2c, server_h2c = create_connections()
to_client_transport = TransportStub(client_h2c)
to_server_transport = TransportStub(server_h2c)
client_conn = Connection(client_h2c, to_server_transport, loop=loop)
server_conn = Connection(server_h2c, to_client_transport, loop=loop)
server_proc = EventsProcessor(DummyHandler(), server_conn)
client_proc = EventsProcessor(DummyHandler(), client_conn)
request = Request(method='POST', scheme='http', path='/',
content_type='application/grpc+proto',
authority='test.com')
client_h2_stream = client_conn.create_stream()
await client_h2_stream.send_request(request.to_headers(),
_processor=client_proc)
request = DummyRequest(value='ping')
await send_message(client_h2_stream, ProtoCodec(), request, DummyRequest,
end=True)
to_server_transport.process(server_proc)
server_h2_stream = server_proc.handler.stream
request_metadata = decode_metadata(server_proc.handler.headers)
with pytest.raises(WriteError):
async with Stream(server_h2_stream, Cardinality.UNARY_UNARY,
ProtoCodec(), DummyRequest, DummyReply,
metadata=request_metadata) as server_stream:
await server_stream.recv_message()
# simulate broken connection
to_client_transport.__raise_on_write__(WriteError)
async def test_exit_and_stream_was_closed(loop):
client_h2c, server_h2c = create_connections()
to_client_transport = TransportStub(client_h2c)
to_server_transport = TransportStub(server_h2c)
client_conn = Connection(client_h2c, to_server_transport, loop=loop)
server_conn = Connection(server_h2c, to_client_transport, loop=loop)
server_proc = EventsProcessor(DummyHandler(), server_conn)
client_proc = EventsProcessor(DummyHandler(), client_conn)
client_h2_stream = client_conn.create_stream()
await client_h2_stream.send_request(create_headers(),
_processor=client_proc)
request = DummyRequest(value='ping')
await send_message(client_h2_stream, ProtoCodec(), request, DummyRequest,
end=True)
to_server_transport.process(server_proc)
server_h2_stream = server_proc.handler.stream
request_metadata = decode_metadata(server_proc.handler.headers)
async with mk_stream(server_h2_stream, request_metadata) as server_stream:
await server_stream.recv_message()
# simulating client closing stream
await client_h2_stream.reset()
to_server_transport.process(server_proc)
# we should fail here on this attempt to send something
await server_stream.send_message(DummyReply(value='pong'))
def test_decode_metadata_empty():
metadata = decode_metadata([
(':method', 'POST'),
('te', 'trailers'),
('content-type', 'application/grpc'),
('user-agent', 'Test'),
('grpc-timeout', '100m'),
])
assert metadata == MultiDict()
def test_decode_metadata_regular(key, value, expected):
metadata = decode_metadata([
(':method', 'POST'),
('te', 'trailers'),
('content-type', 'application/grpc'),
('user-agent', 'Test'),
('grpc-timeout', '100m'),
(key, value),
])
assert metadata == MultiDict({key: expected})
assert type(metadata[key]) is type(expected)
