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 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'])
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())
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 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 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', })
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_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()
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()
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) -> 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_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_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, 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_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 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_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) -> 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_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
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)
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
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
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
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
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 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
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_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'}
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: 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"}
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"
def aiohttp_payload(data, encoding="utf8"): payload = RequestEncodingMixin._encode_params(data).encode(encoding) stream = StreamReader() stream.feed_data(payload) stream.feed_eof() return stream