def mock_stream(data):
"""Mock a stream with data."""
protocol = mock.Mock(_reading_paused=False)
stream = StreamReader(protocol)
stream.feed_data(data)
stream.feed_eof()
return stream
async def test_cannot_clone_after_read(loop, protocol):
payload = StreamReader(protocol, loop=loop)
payload.feed_data(b'data')
payload.feed_eof()
req = make_mocked_request('GET', '/path', payload=payload)
await req.read()
with pytest.raises(RuntimeError):
req.clone()
def test_cannot_clone_after_read(loop):
payload = StreamReader(loop=loop)
payload.feed_data(b'data')
payload.feed_eof()
req = make_mocked_request('GET', '/path', payload=payload)
yield from req.read()
with pytest.raises(RuntimeError):
req.clone()
async def test_reading_long_part(self, newline) -> None:
size = 2 * stream_reader_default_limit
protocol = mock.Mock(_reading_paused=False)
stream = StreamReader(protocol)
stream.feed_data(b'0' * size + b'%s--:--' % newline)
stream.feed_eof()
obj = aiohttp.BodyPartReader(BOUNDARY, {}, stream, _newline=newline)
data = await obj.read()
assert len(data) == size
async def test_request_with_wrong_content_type_encoding(protocol) -> None:
payload = StreamReader(protocol)
payload.feed_data(b'{}')
payload.feed_eof()
headers = {'Content-Type': 'text/html; charset=test'}
req = make_mocked_request('POST', '/', payload=payload, headers=headers)
with pytest.raises(HTTPUnsupportedMediaType) as err:
await req.text()
assert err.value.status_code == 415
async def test_make_too_big_request_adjust_limit(loop, protocol):
payload = StreamReader(protocol, loop=loop)
large_file = 1024 ** 2 * b'x'
too_large_file = large_file + b'x'
payload.feed_data(too_large_file)
payload.feed_eof()
max_size = 1024**2 + 2
req = make_mocked_request('POST', '/', payload=payload,
client_max_size=max_size)
txt = await req.read()
assert len(txt) == 1024**2 + 1
def test_make_too_big_request(loop):
payload = StreamReader(loop=loop)
large_file = 1024 ** 2 * b'x'
too_large_file = large_file + b'x'
payload.feed_data(too_large_file)
payload.feed_eof()
req = make_mocked_request('POST', '/', payload=payload)
with pytest.raises(HTTPRequestEntityTooLarge) as err:
yield from req.read()
assert err.value.status_code == 413
async def test_make_too_big_request(protocol) -> None:
payload = StreamReader(protocol)
large_file = 1024 ** 2 * b'x'
too_large_file = large_file + b'x'
payload.feed_data(too_large_file)
payload.feed_eof()
req = make_mocked_request('POST', '/', payload=payload)
with pytest.raises(HTTPRequestEntityTooLarge) as err:
await req.read()
assert err.value.status_code == 413
async def read_all(stream_reader: StreamReader) -> bytes:
content = list()
print("running read_all")
while not stream_reader.is_eof():
line = await stream_reader.readline()
print("line is: ", line)
content.append(line)
print("end of while loop")
return b"".join(content)
async def test_response_too_large(self):
request_data = bytearray([2, 3, 4])
request_frame = bytearray([0, 0, 0, 3]) + request_data
request_payload = base64.b64encode(request_frame)
response_data = bytearray([6, 7, 8, 9, 10, 11])
request_payload_reader = StreamReader()
request_payload_reader.feed_data(request_payload)
request_payload_reader.feed_eof()
headers = CIMultiDict({
'x-frugal-payload-limit': '5',
})
request = test_utils.make_mocked_request(
'POST', '/frugal', payload=request_payload_reader, headers=headers)
async def process_data(_, oprot):
oprot.get_transport().write(response_data)
self.processor.process.side_effect = process_data
response = await self.handler(request)
self.assertEqual(413, response.status)
self.assertTrue(self.processor.process.called)
iprot, _ = self.processor.process.call_args[0]
self.assertEqual(request_data, iprot.get_transport().getvalue())
async def create_stream(data: bytes):
loop = asyncio.get_event_loop()
protocol = Mock(_reading_paused=False)
stream = StreamReader(protocol, loop=loop)
stream.feed_data(data)
stream.feed_eof()
return stream
async def test_basic(self):
request_data = bytearray([2, 3, 4])
request_frame = bytearray([0, 0, 0, 3]) + request_data
request_payload = base64.b64encode(request_frame)
response_data = bytearray([6, 7, 8, 9])
response_frame = bytearray([0, 0, 0, 4]) + response_data
request_payload_reader = StreamReader()
request_payload_reader.feed_data(request_payload)
request_payload_reader.feed_eof()
request = test_utils.make_mocked_request(
'POST', '/frugal', payload=request_payload_reader)
async def process_data(_, oprot):
oprot.get_transport().write(response_data)
self.processor.process.side_effect = process_data
response = await self.handler(request)
self.assertEqual(200, response.status)
self.assertTrue(self.processor.process.called)
iprot, _ = self.processor.process.call_args[0]
self.assertEqual(request_data, iprot.get_transport().getvalue())
received_payload = base64.b64decode(response.text)
self.assertEqual(response_frame, received_payload)
self.assertEqual('application/x-frugal',
response.headers['content-type'])
self.assertEqual('base64',
response.headers['content-transfer-encoding'])
def mock_stream(data):
"""Mock a stream with data."""
protocol = mock.Mock(_reading_paused=False)
stream = StreamReader(protocol, limit=2**16)
stream.feed_data(data)
stream.feed_eof()
return stream
def function79(arg2239):
var1935 = StreamReader(loop=arg2239)
var1935.feed_data(b'-----------------------------326931944431359\r\nContent-Disposition: form-data; name="a"\r\n\r\nb\r\n-----------------------------326931944431359\r\nContent-Disposition: form-data; name="c"\r\n\r\nd\r\n-----------------------------326931944431359--\r\n')
var2159 = 'multipart/form-data; boundary=---------------------------326931944431359'
var1935.feed_eof()
var1574 = make_mocked_request('POST', '/', headers={'CONTENT-TYPE': content_type, }, payload=var1935)
var1449 = yield from var1574.post()
assert (dict(var1449) == {'a': 'b', 'c': 'd', })
async def test_cannot_clone_after_read(protocol: Any) -> None:
payload = StreamReader(protocol, 2**16, loop=asyncio.get_event_loop())
payload.feed_data(b"data")
payload.feed_eof()
req = make_mocked_request("GET", "/path", payload=payload)
await req.read()
with pytest.raises(RuntimeError):
req.clone()
def function2261(arg225):
var1504 = StreamReader(loop=arg225)
var1504.feed_data(b'data')
var1504.feed_eof()
var4253 = make_mocked_request('GET', '/path', payload=var1504)
yield from var4253.read()
with pytest.raises(RuntimeError):
var4253.clone()
def test_cannot_clone_after_read(loop):
payload = StreamReader(loop=loop)
payload.feed_data(b'data')
payload.feed_eof()
req = make_mocked_request('GET', '/path', payload=payload)
yield from req.read()
with pytest.raises(RuntimeError):
req.clone()
async def test_cannot_clone_after_read(loop, protocol) -> None:
payload = StreamReader(protocol, loop=loop)
payload.feed_data(b'data')
payload.feed_eof()
req = make_mocked_request('GET', '/path', payload=payload)
await req.read()
with pytest.raises(RuntimeError):
req.clone()
async def test_reading_long_part(self, newline) -> None:
size = 2 * stream_reader_default_limit
protocol = mock.Mock(_reading_paused=False)
stream = StreamReader(protocol, loop=asyncio.get_event_loop())
stream.feed_data(b'0' * size + b'%s--:--' % newline)
stream.feed_eof()
obj = aiohttp.BodyPartReader(BOUNDARY, {}, stream, _newline=newline)
data = await obj.read()
assert len(data) == size
async def test_make_too_big_request_same_size_to_max(protocol: Any) -> None:
payload = StreamReader(protocol, 2**16, loop=asyncio.get_event_loop())
large_file = 1024**2 * b"x"
payload.feed_data(large_file)
payload.feed_eof()
req = make_mocked_request("POST", "/", payload=payload)
resp_text = await req.read()
assert resp_text == large_file
async def test_reading_long_part(self, newline: Any) -> None:
size = 2 * 2**16
protocol = mock.Mock(_reading_paused=False)
stream = StreamReader(protocol, 2**16, loop=asyncio.get_event_loop())
stream.feed_data(b"0" * size + b"%s--:--" % newline)
stream.feed_eof()
obj = aiohttp.BodyPartReader(BOUNDARY, {}, stream, _newline=newline)
data = await obj.read()
assert len(data) == size
async def test_reading_long_part(self) -> None:
size = 2 * stream_reader_default_limit
protocol = mock.Mock(_reading_paused=False)
stream = StreamReader(protocol)
stream.feed_data(b'0' * size + b'\r\n--:--')
stream.feed_eof()
obj = aiohttp.BodyPartReader(BOUNDARY, {}, stream)
data = await obj.read()
assert len(data) == size
async def test_request_with_wrong_content_type_encoding(protocol) -> None:
payload = StreamReader(protocol, loop=asyncio.get_event_loop())
payload.feed_data(b'{}')
payload.feed_eof()
headers = {'Content-Type': 'text/html; charset=test'}
req = make_mocked_request('POST', '/', payload=payload, headers=headers)
with pytest.raises(HTTPUnsupportedMediaType) as err:
await req.text()
assert err.value.status_code == 415
async def test_request_with_wrong_content_type_encoding(protocol: Any) -> None:
payload = StreamReader(protocol, 2**16, loop=asyncio.get_event_loop())
payload.feed_data(b"{}")
payload.feed_eof()
headers = {"Content-Type": "text/html; charset=test"}
req = make_mocked_request("POST", "/", payload=payload, headers=headers)
with pytest.raises(HTTPUnsupportedMediaType) as err:
await req.text()
assert err.value.status_code == 415
async def test_make_too_big_request_limit_None(protocol: Any) -> None:
payload = StreamReader(protocol, 2 ** 16, loop=asyncio.get_event_loop())
large_file = 1024 ** 2 * b"x"
too_large_file = large_file + b"x"
payload.feed_data(too_large_file)
payload.feed_eof()
max_size = None
req = make_mocked_request("POST", "/", payload=payload, client_max_size=max_size)
txt = await req.read()
assert len(txt) == 1024 ** 2 + 1
def function543(arg1299):
var4619 = StreamReader(loop=arg1299)
var4228 = ((1024 ** 2) * b'x')
var3630 = (var4228 + b'x')
var4619.feed_data(var3630)
var4619.feed_eof()
var2133 = None
var2226 = make_mocked_request('POST', '/', payload=var4619, client_max_size=var2133)
var763 = yield from var2226.read()
assert (len(var763) == ((1024 ** 2) + 1))
def function2708(arg1590):
var4562 = StreamReader(loop=arg1590)
var868 = ((1024 ** 2) * b'x')
var42 = (var868 + b'x')
var4562.feed_data(var42)
var4562.feed_eof()
var1665 = make_mocked_request('POST', '/', payload=var4562)
with pytest.raises(HTTPRequestEntityTooLarge) as var4182:
yield from var1665.read()
assert (var4182.value.status_code == 413)
def function2019(arg903):
var527 = StreamReader(loop=arg903)
var2480 = ((1024 ** 2) * b'x')
var2565 = (var2480 + b'x')
var527.feed_data(var2565)
var527.feed_eof()
var253 = ((1024 ** 2) + 2)
var151 = make_mocked_request('POST', '/', payload=var527, client_max_size=var253)
var1953 = yield from var151.read()
assert (len(var1953) == ((1024 ** 2) + 1))
async def test_make_too_big_request_adjust_limit(protocol) -> None:
payload = StreamReader(protocol, loop=asyncio.get_event_loop())
large_file = 1024 ** 2 * b'x'
too_large_file = large_file + b'x'
payload.feed_data(too_large_file)
payload.feed_eof()
max_size = 1024**2 + 2
req = make_mocked_request('POST', '/', payload=payload,
client_max_size=max_size)
txt = await req.read()
assert len(txt) == 1024**2 + 1
def mock_request(data, loop):
payload = StreamReader("http", loop=loop)
payload.feed_data(data.encode())
payload.feed_eof()
protocol = mock.Mock()
app = mock.Mock()
headers = CIMultiDict([('CONTENT-TYPE', 'application/json')])
req = make_mocked_request('POST', '/sensor-reading', headers=headers,
protocol=protocol, payload=payload, app=app, loop=loop)
return req
def test_make_too_big_request_limit_None(loop):
payload = StreamReader(loop=loop)
large_file = 1024 ** 2 * b'x'
too_large_file = large_file + b'x'
payload.feed_data(too_large_file)
payload.feed_eof()
max_size = None
req = make_mocked_request('POST', '/', payload=payload,
client_max_size=max_size)
txt = yield from req.read()
assert len(txt) == 1024**2 + 1
async def test_make_too_big_request(protocol: Any) -> None:
payload = StreamReader(protocol, 2**16, loop=asyncio.get_event_loop())
large_file = 1024**2 * b"x"
too_large_file = large_file + b"x"
payload.feed_data(too_large_file)
payload.feed_eof()
req = make_mocked_request("POST", "/", payload=payload)
with pytest.raises(HTTPRequestEntityTooLarge) as err:
await req.read()
assert err.value.status_code == 413
async def test_make_too_big_request(loop, protocol) -> None:
payload = StreamReader(protocol, loop=loop)
large_file = 1024**2 * b'x'
too_large_file = large_file + b'x'
payload.feed_data(too_large_file)
payload.feed_eof()
req = make_mocked_request('POST', '/', payload=payload)
with pytest.raises(HTTPRequestEntityTooLarge) as err:
await req.read()
assert err.value.status_code == 413
def test_multipart_formdata(loop):
payload = StreamReader(loop=loop)
payload.feed_data(b"""-----------------------------326931944431359\r
Content-Disposition: form-data; name="a"\r
\r
b\r
-----------------------------326931944431359\r
Content-Disposition: form-data; name="c"\r
\r
d\r
-----------------------------326931944431359--\r\n""")
content_type = "multipart/form-data; boundary="\
"---------------------------326931944431359"
payload.feed_eof()
req = make_mocked_request('POST', '/',
headers={'CONTENT-TYPE': content_type},
payload=payload)
result = yield from req.post()
assert dict(result) == {'a': 'b', 'c': 'd'}
async def test_multipart_formdata(protocol) -> None:
payload = StreamReader(protocol, loop=asyncio.get_event_loop())
payload.feed_data(b"""-----------------------------326931944431359\r
Content-Disposition: form-data; name="a"\r
\r
b\r
-----------------------------326931944431359\r
Content-Disposition: form-data; name="c"\r
\r
d\r
-----------------------------326931944431359--\r\n""")
content_type = "multipart/form-data; boundary="\
"---------------------------326931944431359"
payload.feed_eof()
req = make_mocked_request('POST', '/',
headers={'CONTENT-TYPE': content_type},
payload=payload)
result = await req.post()
assert dict(result) == {'a': 'b', 'c': 'd'}
async def test_multipart_formdata_file(protocol) -> None:
# Make sure file uploads work, even without a content type
payload = StreamReader(protocol, 2**16, loop=asyncio.get_event_loop())
payload.feed_data(
b"-----------------------------326931944431359\r\n"
b'Content-Disposition: form-data; name="a_file"; filename="binary"\r\n'
b"\r\n"
b"\ff\r\n"
b"-----------------------------326931944431359--\r\n")
content_type = ("multipart/form-data; boundary="
"---------------------------326931944431359")
payload.feed_eof()
req = make_mocked_request("POST",
"/",
headers={"CONTENT-TYPE": content_type},
payload=payload)
result = await req.post()
assert hasattr(result["a_file"], "file")
content = result["a_file"].file.read()
assert content == b"\ff"
async def test_multipart_formdata(protocol: Any) -> None:
payload = StreamReader(protocol, 2**16, loop=asyncio.get_event_loop())
payload.feed_data(b"-----------------------------326931944431359\r\n"
b'Content-Disposition: form-data; name="a"\r\n'
b"\r\n"
b"b\r\n"
b"-----------------------------326931944431359\r\n"
b'Content-Disposition: form-data; name="c"\r\n'
b"\r\n"
b"d\r\n"
b"-----------------------------326931944431359--\r\n")
content_type = ("multipart/form-data; boundary="
"---------------------------326931944431359")
payload.feed_eof()
req = make_mocked_request("POST",
"/",
headers={"CONTENT-TYPE": content_type},
payload=payload)
result = await req.post()
assert dict(result) == {"a": "b", "c": "d"}
def aiohttp_payload(data, encoding="utf8"):
payload = RequestEncodingMixin._encode_params(data).encode(encoding)
stream = StreamReader()
stream.feed_data(payload)
stream.feed_eof()
return stream
