def test_set_exception(loop):
reader = streams.StreamReader(loop=loop)
waiter = reader._waiter = loop.create_future()
eof_waiter = reader._eof_waiter = loop.create_future()
exc = ValueError()
reader.set_exception(exc)
assert waiter.exception() is exc
assert eof_waiter.exception() is exc
assert reader._waiter is None
assert reader._eof_waiter is None
async def test_stream_reader_iter_chunks_chunked_encoding(loop, protocol):
stream = streams.StreamReader(protocol, loop=loop)
for line in DATA.splitlines(keepends=True):
stream.begin_http_chunk_receiving()
stream.feed_data(line)
stream.end_http_chunk_receiving()
stream.feed_eof()
it = iter([b'line1\n', b'line2\n', b'line3\n'])
async for data, end_of_chunk in stream.iter_chunks():
assert (data, end_of_chunk) == (next(it), True)
pytest.raises(StopIteration, next, it)
def function2145(arg180):
var1226 = streams.StreamReader(loop=arg180)
var3512 = var1226._waiter = helpers.create_future(arg180)
var1757 = var1226._eof_waiter = helpers.create_future(arg180)
var3512.set_result(1)
var1757.set_result(1)
var2994 = ValueError()
var1226.set_exception(var2994)
assert (var3512.exception() is None)
assert (var1757.exception() is None)
assert (var1226._waiter is None)
assert (var1226._eof_waiter is None)
async def test_on_eof_exc_in_callback(protocol) -> None:
loop = asyncio.get_event_loop()
reader = streams.StreamReader(protocol, loop=loop)
on_eof = mock.Mock()
on_eof.side_effect = ValueError
reader.on_eof(on_eof)
assert not on_eof.called
reader.feed_eof()
assert on_eof.called
assert not reader._eof_callbacks
def test_feed_eof_waiters(loop):
reader = streams.StreamReader(loop=loop)
waiter = reader._waiter = helpers.create_future(loop)
eof_waiter = reader._eof_waiter = helpers.create_future(loop)
reader.feed_eof()
assert reader._eof
assert waiter.done()
assert eof_waiter.done()
assert reader._waiter is None
assert reader._eof_waiter is None
def test_feed_eof_waiters(loop, protocol):
reader = streams.StreamReader(protocol, loop=loop)
waiter = reader._waiter = loop.create_future()
eof_waiter = reader._eof_waiter = loop.create_future()
reader.feed_eof()
assert reader._eof
assert waiter.done()
assert eof_waiter.done()
assert reader._waiter is None
assert reader._eof_waiter is None
def function569(arg1357):
var1577 = streams.StreamReader(loop=arg1357)
var2495 = var1577._waiter = helpers.create_future(arg1357)
var1147 = var1577._eof_waiter = helpers.create_future(arg1357)
var1577.feed_data(b'1')
assert (list(var1577._buffer) == [b'1'])
assert (var1577._size == 1)
assert (var1577.total_bytes == 1)
assert var2495.done()
assert (not var1147.done())
assert (var1577._waiter is None)
assert (var1577._eof_waiter is var1147)
async def test_feed_eof_waiters(protocol) -> None:
loop = asyncio.get_event_loop()
reader = streams.StreamReader(protocol, 2 ** 16, loop=loop)
waiter = reader._waiter = loop.create_future()
eof_waiter = reader._eof_waiter = loop.create_future()
reader.feed_eof()
assert reader._eof
assert waiter.done()
assert eof_waiter.done()
assert reader._waiter is None
assert reader._eof_waiter is None
async def test_set_exception(protocol) -> None:
loop = asyncio.get_event_loop()
reader = streams.StreamReader(protocol, 2 ** 16, loop=loop)
waiter = reader._waiter = loop.create_future()
eof_waiter = reader._eof_waiter = loop.create_future()
exc = ValueError()
reader.set_exception(exc)
assert waiter.exception() is exc
assert eof_waiter.exception() is exc
assert reader._waiter is None
assert reader._eof_waiter is None
def test_feed_data_waiters(loop, protocol) -> None:
reader = streams.StreamReader(protocol, loop=loop)
waiter = reader._waiter = loop.create_future()
eof_waiter = reader._eof_waiter = loop.create_future()
reader.feed_data(b'1')
assert list(reader._buffer) == [b'1']
assert reader._size == 1
assert reader.total_bytes == 1
assert waiter.done()
assert not eof_waiter.done()
assert reader._waiter is None
assert reader._eof_waiter is eof_waiter
async def test_stream_reader_iter_chunks_chunked_encoding(
protocol: Any) -> None:
loop = asyncio.get_event_loop()
stream = streams.StreamReader(protocol, 2**16, loop=loop)
for line in DATA.splitlines(keepends=True):
stream.begin_http_chunk_receiving()
stream.feed_data(line)
stream.end_http_chunk_receiving()
stream.feed_eof()
it = iter([b"line1\n", b"line2\n", b"line3\n"])
async for data, end_of_chunk in stream.iter_chunks():
assert (data, end_of_chunk) == (next(it), True)
pytest.raises(StopIteration, next, it)
async def invoke(app, request, args):
headers = args.get('__ow_headers', {})
method = args.get('__ow_method', 'GET').upper()
path = args.get('__ow_path', '/')
body = None
if method in ('POST', 'PUT'):
content_type = headers.get('content-type', 'application/octet-stream')
parsed_content_type = http.parse_options_header(content_type)
raw = args.get('__ow_body')
if parsed_content_type[0][0:5] == 'text/':
body = raw.encode(parsed_content_type[1].get('charset', 'utf-8'))
else:
body = base64.b64decode(raw) if raw is not None else None
request = request.clone(method=method,
rel_url=path,
headers=get_headers(headers))
request._payload = streams.StreamReader(request._payload._protocol)
request._payload.feed_data(body)
request._payload.feed_eof()
match_info = await _normalize(request, app)
if match_info is None:
response = web.HTTPNotFound()
else:
request._match_info = match_info
try:
if path == "/swagger.json":
response = await match_info.handler(request)
else:
response = await match_info.handler(request, wsk_args=args)
except web.HTTPException as e:
response = e
response_type = http.parse_options_header(
response.headers.get('Content-Type', 'application/octet-stream'))
if not response.body:
body = None
elif response_type[0][0:response_type[0].find('/')] != 'octet-stream':
body = response.body.decode(response_type[1].get('charset', 'utf-8'))
else:
body = base64.b64encode(response.text)
return {
'headers': dict(response.headers),
'statusCode': response.status,
'body': body
}
def make_request(method, path, *, loop=None, headers=sentinel, data=None):
if headers is sentinel:
headers = {'Content-Type': 'application/json'}
elif 'Content-Type' not in headers:
headers['Content-Type'] = 'application/json'
if data is not None:
data = json.dumps(data).encode()
payload = streams.StreamReader(loop=loop)
payload.feed_data(data)
payload.feed_eof()
headers.update({'Content-Length': str(len(data))})
else:
payload = sentinel
return make_mocked_request(method, path, headers=headers, payload=payload)
def test_feed_data_waiters(loop):
reader = streams.StreamReader(loop=loop)
waiter = reader._waiter = helpers.create_future(loop)
eof_waiter = reader._eof_waiter = helpers.create_future(loop)
reader.feed_data(b'1')
assert list(reader._buffer) == [b'1']
assert reader._size == 1
assert reader.total_bytes == 1
assert waiter.done()
assert not eof_waiter.done()
assert reader._waiter is None
assert reader._eof_waiter is eof_waiter
def test_feed_eof_cancelled(loop, protocol):
reader = streams.StreamReader(protocol, loop=loop)
waiter = reader._waiter = loop.create_future()
eof_waiter = reader._eof_waiter = loop.create_future()
waiter.set_result(1)
eof_waiter.set_result(1)
reader.feed_eof()
assert waiter.done()
assert eof_waiter.done()
assert reader._waiter is None
assert reader._eof_waiter is None
def test_feed_eof_cancelled(loop):
reader = streams.StreamReader(loop=loop)
waiter = reader._waiter = helpers.create_future(loop)
eof_waiter = reader._eof_waiter = helpers.create_future(loop)
waiter.set_result(1)
eof_waiter.set_result(1)
reader.feed_eof()
assert waiter.done()
assert eof_waiter.done()
assert reader._waiter is None
assert reader._eof_waiter is None
def test_set_exception_cancelled(loop):
reader = streams.StreamReader(loop=loop)
waiter = reader._waiter = helpers.create_future(loop)
eof_waiter = reader._eof_waiter = helpers.create_future(loop)
waiter.set_result(1)
eof_waiter.set_result(1)
exc = ValueError()
reader.set_exception(exc)
assert waiter.exception() is None
assert eof_waiter.exception() is None
assert reader._waiter is None
assert reader._eof_waiter is None
async def test_stream_reader_long_lines(loop) -> None:
DATA = b'0' * 1024**3
stream = streams.StreamReader(mock.Mock(), loop=loop)
stream.feed_data(DATA)
stream.feed_eof()
body = payload.get_payload(stream)
writer = mock.Mock()
writer.write.return_value = loop.create_future()
writer.write.return_value.set_result(None)
await body.write(writer)
writer.write.assert_called_once_with(mock.ANY)
(chunk, ), _ = writer.write.call_args
assert len(chunk) == len(DATA)
def test_set_exception_cancelled(loop, protocol) -> None:
reader = streams.StreamReader(protocol, loop=loop)
waiter = reader._waiter = loop.create_future()
eof_waiter = reader._eof_waiter = loop.create_future()
waiter.set_result(1)
eof_waiter.set_result(1)
exc = ValueError()
reader.set_exception(exc)
assert waiter.exception() is None
assert eof_waiter.exception() is None
assert reader._waiter is None
assert reader._eof_waiter is None
async def test_feed_eof_cancelled(protocol) -> None:
loop = asyncio.get_event_loop()
reader = streams.StreamReader(protocol, loop=loop)
waiter = reader._waiter = loop.create_future()
eof_waiter = reader._eof_waiter = loop.create_future()
waiter.set_result(1)
eof_waiter.set_result(1)
reader.feed_eof()
assert waiter.done()
assert eof_waiter.done()
assert reader._waiter is None
assert reader._eof_waiter is None
async def test_feed_data_waiters(protocol) -> None:
loop = asyncio.get_event_loop()
reader = streams.StreamReader(protocol, 2 ** 16, loop=loop)
waiter = reader._waiter = loop.create_future()
eof_waiter = reader._eof_waiter = loop.create_future()
reader.feed_data(b"1")
assert list(reader._buffer) == [b"1"]
assert reader._size == 1
assert reader.total_bytes == 1
assert waiter.done()
assert not eof_waiter.done()
assert reader._waiter is None
assert reader._eof_waiter is eof_waiter
def get_request(app,
path='/',
method='GET',
content=None,
auth=None,
content_type=None,
headers=None,
json_encode=True):
"""Create a test request.
The `auth` parameter for Basic-Authorization can be provided as tuple with
(user, password).
If `json_encode` is set to False, the content is not converted to JSON (in
which case it should be bytes).
"""
if headers is None:
headers = {}
if auth is not None:
headers.update(basic_auth_header(*auth))
if json_encode and content is None:
content = {}
if content is not None:
payload = streams.StreamReader(loop=app.loop)
if json_encode:
data = json.dumps(content).encode('utf-8')
else:
data = content
payload.feed_data(data)
payload.feed_eof()
headers.update({
'Content-Type': 'application/json',
'Content-Length': str(len(data))
})
else:
payload = sentinel
if content_type is not None:
headers['Content-Type'] = content_type
return make_mocked_request(method,
path,
app=app,
payload=payload,
headers=headers)
async def test_issues_event(loop):
headers = {
'User-Agent': 'GitHub-Hookshot/abcde',
'Content-Type': 'application/json',
'X-GitHub-Event': 'issues',
'X-GitHub-Delivery': 'askfjbcalskeuhfaw3r',
'X-Hub-Signature': 'q3r5awfeaea',
}
protocol = mock.Mock(_reading_paused=False)
payload = streams.StreamReader(protocol=protocol, limit=2 ** 16, loop=loop)
payload.feed_data(PAYLOAD)
payload.feed_eof()
webhook_request = make_mocked_request('POST', '/', headers=headers, payload=payload)
event = await github.Event(webhook_request)
assert isinstance(event, github.EventType)
assert event.app
assert event.key == 'issue'
assert event.type == 'issues'
assert event.action == 'opened'
def _make_one(self, *args, **kwargs):
loop = asyncio.get_event_loop()
kwargs.setdefault("limit", 2 ** 16)
return streams.StreamReader(
mock.Mock(_reading_paused=False), *args, **kwargs, loop=loop
)
def test_ctor_global_loop(self, m_asyncio):
stream = streams.StreamReader()
self.assertIs(stream._loop, m_asyncio.get_event_loop.return_value)
def _make_one(self, *args, **kwargs):
return streams.StreamReader(loop=self.loop, *args, **kwargs)
def test_ctor_global_loop(self):
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
stream = streams.StreamReader(mock.Mock(_reading_paused=False))
assert stream._loop is loop
def _make_one(self, *args, **kwargs):
return streams.StreamReader(mock.Mock(_reading_paused=False), *args,
**kwargs)
def create_stream(loop):
stream = streams.StreamReader(loop=loop)
stream.feed_data(DATA)
stream.feed_eof()
return stream
def create_stream(loop):
protocol = mock.Mock(_reading_paused=False)
stream = streams.StreamReader(protocol, loop=loop)
stream.feed_data(DATA)
stream.feed_eof()
return stream
